[关闭]
@leaveye 2026-04-28T10:16:52.000000Z 字数 20282 阅读 27

ws-proto

wireshark lua script ws protocol

wsproto.lua

  1. --[[
  2. -- Drop this file into `plugins` folder in Wireshark folder, which
  3. -- should contains `profiles` folder in it.
  4. --]]
  6. -- set UDP ports for the dissectors
  7. local ws_proto = { audio_port = 4600, video_port = 4602, subtitle_port = 4604 }
  9. -----------------------------------------------------------------------------
  11. local base = base
  12. local ByteArray = ByteArray
  13. local Dissector = Dissector
  14. local DissectorTable = DissectorTable
  15. local ENC_GB18030 = ENC_GB18030
  16. local Proto = Proto
  17. local ProtoField = ProtoField
  19. -----------------------------------------------------------------------------
  21. local mpeg1layer2_proto = Dissector.get("mpeg-audio")
  22. local h264raw_proto = Dissector.get("h264_bytestream") or Dissector.get("h264")
  24. local function with_proto(name, description, fn)
  25.     local proto = Proto(name, description)
  26.     fn(proto)
  27.     return proto
  28. end
  30. local function have_prefix(buffer, prefix)
  31.     local want_len = #prefix
  32.     return buffer:len() >= want_len and buffer:raw(0, want_len) == prefix
  33. end
  35. local function format_bits(data, bitsize, bitmask)
  36.     local format_string = ""
  37.     for i = 1, bitsize, 1 do
  38.         local cur_data, cur_mask = data >> (i - 1), bitmask >> (i - 1)
  39.         local value_bit, mask_bit = cur_data & 1, cur_mask & 1
  40.         local need_gap = (i & 3) == 1 and i >= 4
  41.         format_string = (mask_bit == 0 and "." or (value_bit ~= 0 and "1" or "0"))
  42.             .. (need_gap and " " or "")
  43.             .. format_string
  44.     end
  45.     return format_string
  46. end
  48. -----------------------------------------------------------------------------
  50. ws_proto.audio = with_proto("WsAudio", "WS audio proto", function(proto)
  51.     local fields = {
  52.         index = ProtoField.uint16("WsAudio.index", "Index", base.DEC),
  53.         timestamp = ProtoField.double("WsAudio.timestamp", "TS", base.DOUBLE),
  54.         len = ProtoField.uint16("WsAudio.len", "Len", base.DEC),
  55.         data = ProtoField.bytes("WsAudio.data", "Data"),
  56.     }
  57.     proto.fields = fields
  59.     function proto.dissector(buffer, pinfo, tree)
  60.         local subtree = tree:add(proto, buffer(), "WS Audio Packet")
  61.         local pkt_index = buffer(2, 2):le_uint()
  62.         subtree:append_text((", idx %u"):format(pkt_index))
  63.         subtree:add(fields.len, buffer(0, 2), buffer(0, 2):le_uint())
  64.         subtree:add(fields.index, buffer(2, 2), pkt_index)
  65.         subtree:add(
  66.             fields.timestamp,
  67.             buffer(4, 4),
  68.             tonumber(("%u.%04u"):format(buffer(4, 2):le_uint(), buffer(6, 2):le_uint()))
  69.         )
  71.         if mpeg1layer2_proto then
  72.             mpeg1layer2_proto:call(buffer(8, -1):tvb(), pinfo, tree)
  73.             pinfo.cols.protocol:set("Ws:" .. tostring(pinfo.cols.protocol))
  74.             pinfo.cols.info:prepend(("idx %u, "):format(pkt_index))
  75.         else
  76.             subtree:add(fields.data, buffer(8, -1))
  77.             pinfo.cols.protocol:set("Ws:Mp2")
  78.             pinfo.cols.info:set(("idx %u, %s"):format(pkt_index, "Audio Layer 2"))
  79.         end
  80.     end
  81. end)
  83. -----------------------------------------------------------------------------
  85. ws_proto.video = with_proto("WsVideo", "WS video proto", function(proto)
  86.     local fields = {
  87.         data = ProtoField.bytes("WsVideo.data", "Data"),
  88.     }
  89.     proto.fields = fields
  91.     local packet_types = { "normal", "config", "fec", "frame-info" }
  92.     local packet_control_bytes = {
  93.         { "RESET", "\xFF\xFE\xFE\xFE\xFF\xFE\xFE\xFE" },
  94.         { "MODE:Changing", "\xFF\xFE\xFE\xFE\xFF\xFE\xFE\xFA" },
  95.         { "MODE:Changed", "\xFF\xFE\xFE\xFE\xFF\xFE\xFE\xFB" },
  96.     }
  98.     ----------------------------------------------------------------
  99.     -- global caches
  100.     ----------------------------------------------------------------
  102.     local IDX_MASK = 0x1FFF -- 8191
  104.     local pkt_cache = {} -- pktno -> meta
  105.     local frame_cache = {} -- frame_key -> state
  106.     local last_frame = nil
  108.     local function clear_cache()
  109.         pkt_cache = {}
  110.         frame_cache = {}
  111.         last_frame = nil
  112.     end
  114.     local function mod_idx(v)
  115.         return v & IDX_MASK
  116.     end
  118.     local function frame_key_of(idx, seq)
  119.         return mod_idx(idx - seq)
  120.     end
  122.     local function get_frame(frame_key)
  123.         local st = frame_cache[frame_key]
  124.         if st then
  125.             return st
  126.         end
  128.         st = {
  129.             key = frame_key,
  130.             want_len = nil,
  131.             got_len = 0,
  132.             max_seq = -1,
  133.             fragments = {}, -- seq -> raw bytes
  134.             pktnos = {}, -- seq -> pktno
  135.             complete = false,
  136.             assembled = nil,
  137.             assembled_once = false,
  138.             checksum = nil,
  139.             timestamp = nil,
  140.             src_addr = nil,
  141.         }
  143.         frame_cache[frame_key] = st
  144.         return st
  145.     end
  147.     local function add_fragment(st, seq, raw, pktno)
  148.         if st.fragments[seq] then
  149.             return false
  150.         end
  152.         st.fragments[seq] = raw
  153.         st.pktnos[seq] = pktno
  154.         st.got_len = st.got_len + #raw
  156.         if seq > st.max_seq then
  157.             st.max_seq = seq
  158.         end
  160.         return true
  161.     end
  163.     local function can_complete(st)
  164.         if not st.want_len then
  165.             return false
  166.         end
  168.         if st.got_len < st.want_len then
  169.             return false
  170.         end
  172.         for i = 0, st.max_seq do
  173.             if not st.fragments[i] then
  174.                 return false
  175.             end
  176.         end
  178.         return true
  179.     end
  181.     local function assemble_frame(st)
  182.         if st.assembled then
  183.             return st.assembled
  184.         end
  186.         local full = ByteArray.new()
  188.         for i = 0, st.max_seq do
  189.             local s = st.fragments[i]
  190.             if not s then
  191.                 return nil
  192.             end
  194.             full:append(ByteArray.new(s, true))
  195.         end
  197.         st.assembled = full
  198.         st.complete = true
  199.         return full
  200.     end
  202.     ----------------------------------------------------------------
  203.     -- control packet
  204.     ----------------------------------------------------------------
  206.     local function dissector_ctrl_bytes(buffer, pinfo, tree)
  207.         for _, check_item in ipairs(packet_control_bytes) do
  208.             local name, payload = table.unpack(check_item)
  209.             local found = have_prefix(buffer, payload)
  211.             if found then
  212.                 local subtree = tree:add(ws_proto.video, buffer(), "WS Video Control Packet: " .. name)
  214.                 local description = "Control:" .. name
  215.                 subtree:add(buffer(0, #payload), description)
  216.                 pinfo.cols.info:set(description)
  217.                 return true
  218.             end
  219.         end
  221.         return false
  222.     end
  224.     ----------------------------------------------------------------
  225.     -- frame header parser
  226.     ----------------------------------------------------------------
  228.     local function parse_frame_header(frame_header, st, pinfo, tree)
  229.         local frame_header_len = frame_header:len()
  231.         if frame_header_len > 13 then
  232.             local payload_len = frame_header(1, 4):le_uint() - frame_header_len
  233.             local checksum = frame_header(5, 4):le_uint()
  234.             local src_addr = frame_header(9, 4):ipv4()
  235.             local timestamp = frame_header(13, 2):le_uint() + 1E-4 * frame_header(15, 2):le_uint()
  237.             st.want_len = payload_len
  238.             st.checksum = checksum
  239.             st.timestamp = timestamp
  240.             st.src_addr = tostring(src_addr)
  242.             pinfo.cols.info:append((" payload %u IDR src %s"):format(payload_len, src_addr))
  244.             local frame_tree = tree:add(frame_header, "IDR frame header")
  245.             frame_tree:add(frame_header(0, 1), format_bits(frame_header(0, 1):uint(), 8, 0x01) .. " = IDR frame")
  246.             frame_tree:add(frame_header(1, 4), ("Len: header %u payload %u"):format(frame_header_len, payload_len))
  247.             frame_tree:add(frame_header(5, 4), ("Checksum: %08X"):format(checksum))
  248.             frame_tree:add(frame_header(9, 4), ("Source Address: %s"):format(src_addr))
  249.             frame_tree:add(frame_header(13, 4), ("Timestamp: %.6f"):format(timestamp))
  250.         else
  251.             local payload_len = frame_header(1, 4):le_uint() - frame_header_len
  252.             local checksum = frame_header(5, 4):le_uint()
  253.             local timestamp = frame_header(9, 2):le_uint() + 1E-4 * frame_header(11, 2):le_uint()
  255.             st.want_len = payload_len
  256.             st.checksum = checksum
  257.             st.timestamp = timestamp
  259.             pinfo.cols.info:append((" payload %u"):format(payload_len))
  261.             local frame_tree = tree:add(frame_header, "non-IDR frame header")
  262.             frame_tree:add(frame_header(0, 1), format_bits(frame_header(0, 1):uint(), 8, 0x01) .. " = P frame")
  263.             frame_tree:add(frame_header(1, 4), ("Len: header %u payload %u"):format(frame_header_len, payload_len))
  264.             frame_tree:add(frame_header(5, 4), ("Checksum: %08X"):format(checksum))
  265.             frame_tree:add(frame_header(9, 4), ("Timestamp: %.6f"):format(timestamp))
  266.         end
  267.     end
  269.     ----------------------------------------------------------------
  270.     -- render payload / assembled
  271.     ----------------------------------------------------------------
  273.     local function render_payload(buffer, payload_tvb, st, seq, pinfo, tree)
  274.         --[[
  275.     tree:add(
  276.             buffer(0, 0),
  277.             ("DEBUG frame=%u want=%s got=%u seq=%u complete=%s"):format(
  278.                 st.key,
  279.                 tostring(st.want_len),
  280.                 st.got_len,
  281.                 seq,
  282.                 tostring(st.complete)
  283.             )
  284.         )
  285.     --]]
  286.         if not h264raw_proto then
  287.             tree:add(fields.data, buffer(), ("Fragment %u of frame %u"):format(seq, st.key))
  288.             pinfo.cols.protocol:set("Ws:V")
  289.             return
  290.         end
  292.         if st.complete then
  293.             local full = assemble_frame(st)
  295.             local assembled_tree = tree:add(
  296.                 proto,
  297.                 buffer(0, 0),
  298.                 ("Reassembled frame %u: %u packets, %u bytes"):format(st.key, st.max_seq + 1, st.want_len or 0)
  299.             )
  301.             local tvb = ByteArray.tvb(full, "Reassembled WS Video Frame")
  302.             h264raw_proto:call(tvb, pinfo, assembled_tree)
  304.             pinfo.cols.protocol:set("Ws:H264")
  305.             return
  306.         end
  308.         local payload_tree = tree:add(buffer(), ("Frame %u: piece %u, %u bytes"):format(st.key, seq, payload_tvb:len()))
  310.         h264raw_proto:call(payload_tvb, pinfo, payload_tree)
  311.         pinfo.cols.protocol:set("Ws:H264")
  312.     end
  314.     ----------------------------------------------------------------
  315.     -- dissector
  316.     ----------------------------------------------------------------
  318.     function proto.init()
  319.         clear_cache()
  320.     end
  322.     function proto.dissector(buffer, pinfo, tree)
  323.         if pinfo.number == 1 and not pinfo.visited then
  324.             clear_cache()
  325.         end
  327.         local is_resend = false
  328.         local offset = 0
  330.         if have_prefix(buffer, "\xFF\xFF\xFF\xFF") then
  331.             is_resend = true
  332.             offset = 4
  333.         elseif dissector_ctrl_bytes(buffer, pinfo, tree) then
  334.             return
  335.         end
  337.         local pkt_tree = tree:add(ws_proto.video, buffer(0, offset + 4), "WS Video Packet Header: ")
  339.         pinfo.cols.info:clear()
  341.         if is_resend then
  342.             pkt_tree:add(buffer(0, offset), "resend mark")
  343.             pinfo.cols.info:prepend("RESEND ")
  344.         end
  346.         local header1 = buffer(offset, 2)
  347.         local header2 = buffer(offset + 2, 2)
  348.         local header1_data = header1:le_uint()
  349.         local header2_data = header2:le_uint()
  351.         local not_full = (header1_data & 0x8000) ~= 0
  352.         local ext_data = (header1_data & 0x4000) ~= 0
  354.         offset = offset + 4
  356.         ------------------------------------------------------------
  357.         -- ext packet
  358.         ------------------------------------------------------------
  359.         if ext_data then
  360.             local ext_type = (header1_data & 0x3C00) >> 10
  361.             local vpkt_type = packet_types[ext_type] or "<unknown>"
  363.             local summary = ("ext(%s)"):format(vpkt_type)
  365.             pinfo.cols.info:append(summary)
  366.             pkt_tree:append_text(summary)
  368.             if not_full then
  369.                 pkt_tree:append_text(" not-full")
  370.             end
  372.             local pkt_index = header1_data & 0x03FF
  373.             local grp_index = header2_data
  375.             pkt_tree:add(header1, format_bits(header1_data, 16, 0x8000) .. " = reserved")
  376.             pkt_tree:add(header1, format_bits(header1_data, 16, 0x4000) .. " = extended")
  377.             pkt_tree:add(header1, format_bits(header1_data, 16, 0x3C00) .. (" = type %s"):format(vpkt_type))
  378.             pkt_tree:add(header1, format_bits(header1_data, 16, 0x03FF) .. (" = sub idx %u"):format(pkt_index))
  379.             pkt_tree:add(header2, format_bits(header2_data, 16, 0x3FFF) .. (" = grp idx %u"):format(grp_index))
  381.             pinfo.cols.info:append((" len %u"):format(buffer:len()))
  382.             return
  383.         end
  385.         ------------------------------------------------------------
  386.         -- normal packet
  387.         ------------------------------------------------------------
  388.         local slot_id = header1_data & 0x3FFF
  389.         local seq_id = header2_data & 0x0FFF
  391.         local summary = ("idx %u seq %u"):format(slot_id, seq_id)
  393.         pinfo.cols.info:append(summary)
  394.         pkt_tree:append_text(summary)
  396.         if not_full then
  397.             pkt_tree:append_text(" not-full")
  398.         end
  400.         pkt_tree:add(
  401.             header1,
  402.             format_bits(header1_data, 16, 0x8000) .. (" = %s"):format(not_full and "not full" or "full (1024 byte)")
  403.         )
  404.         pkt_tree:add(header1, format_bits(header1_data, 16, 0x4000) .. " = normal")
  405.         pkt_tree:add(header1, format_bits(header1_data, 16, 0x3FFF) .. (" = idx %u"):format(slot_id))
  406.         pkt_tree:add(header2, format_bits(header2_data, 16, 0xFFFF) .. (" = seq %u"):format(seq_id))
  408.         pinfo.cols.info:append((" len %u"):format(buffer:len()))
  410.         local frame_key = frame_key_of(slot_id, seq_id)
  411.         local st = get_frame(frame_key)
  413.         local frame_header_len = 0
  415.         if seq_id == 0 then
  416.             local is_idr_frame = buffer(offset, 1):uint() ~= 0
  417.             frame_header_len = is_idr_frame and 17 or 13
  419.             local frame_header = buffer(offset, frame_header_len)
  420.             parse_frame_header(frame_header, st, pinfo, tree)
  422.             offset = offset + frame_header_len
  423.             last_frame = st
  424.         end
  426.         local payload_buf = buffer(offset)
  427.         local payload_tvb = payload_buf:tvb()
  428.         local payload_raw = payload_tvb:raw()
  430.         ------------------------------------------------------------
  431.         -- cache packet meta
  432.         ------------------------------------------------------------
  433.         pkt_cache[pinfo.number] = {
  434.             idx = slot_id,
  435.             seq = seq_id,
  436.             frame_key = frame_key,
  437.             pktno = pinfo.number,
  438.             payload = payload_raw,
  439.             payload_len = #payload_raw,
  440.         }
  442.         ------------------------------------------------------------
  443.         -- merge fragment
  444.         ------------------------------------------------------------
  445.         add_fragment(st, seq_id, payload_raw, pinfo.number)
  447.         if can_complete(st) then
  448.             assemble_frame(st)
  449.         end
  451.         ------------------------------------------------------------
  452.         -- render
  453.         ------------------------------------------------------------
  454.         render_payload(payload_buf, payload_tvb, st, seq_id, pinfo, tree)
  455.     end
  456. end)
  458. -----------------------------------------------------------------------------
  460. ws_proto.subtitle = with_proto("WsSubt", "WS subtitle proto", function(proto)
  461.     local fields = {
  462.         version = ProtoField.uint8("WsSubt.version", "Version", base.DEC),
  463.         data = ProtoField.bytes("WsSubt.data", "Data"),
  464.     }
  465.     proto.fields = fields
  467.     local function v1_dissector(buffer, pinfo, subtree)
  468.         pinfo.cols.protocol:set("Ws:Subt1")
  469.         pinfo.cols.info:set("V1")
  470.         subtree:append_text(" Version 1")
  471.         local count = buffer(0, 4):le_uint()
  472.         subtree:append_text((", total %u items"):format(count))
  473.         subtree:add(buffer(0, 4), ("Count: %u"):format(count))
  474.         local n_chars = buffer(4, 4):le_uint()
  475.         subtree:append_text((" %u chars"):format(n_chars))
  476.         subtree:add(buffer(4, 4), ("Chars: %u"):format(n_chars))
  477.         local item_offset, item_size = 8, 8
  478.         local text_offset = item_offset + count * item_size
  479.         local pad_offset = text_offset + n_chars * 2
  480.         local text_buffer = buffer(text_offset, n_chars * 2)
  481.         local text_past_len = 0
  483.         for i = 1, count do
  484.             local item_buffer = buffer(item_offset + (i - 1) * item_size, item_size)
  485.             local item_tree = subtree:add(item_buffer, ("Item #%u"):format(i - 1))
  486.             local item_string = ""
  487.             local pos_string = ("(%u/720,%u/576)"):format(item_buffer(0, 2):le_uint(), item_buffer(2, 2):le_uint())
  488.             item_tree:add(item_buffer(0, 4), ("Pos: %s"):format(pos_string))
  489.             item_string = item_string .. pos_string
  490.             local item_text_len = item_buffer(4, 2):le_uint()
  491.             item_tree:add(item_buffer(4, 2), ("TextLen: %u"):format(item_text_len))
  492.             if item_text_len > 0 then
  493.                 local item_text_buffer = text_buffer(text_past_len, item_text_len * 2)
  494.                 local item_text = item_text_buffer:string(ENC_GB18030)
  495.                 item_tree:add(item_text_buffer, ('Text: "%s"'):format(item_text))
  496.                 item_string = item_string .. (' "%s"'):format(item_text)
  497.                 text_past_len = text_past_len + item_text_len * 2
  498.             end
  499.         end
  501.         if pad_offset < buffer:len() then
  502.             subtree:add(buffer(pad_offset, -1), "padding")
  503.         end
  504.     end
  506.     local function v2_dissector(buffer, pinfo, subtree)
  507.         pinfo.cols.protocol:set("Ws:Subt2")
  508.         pinfo.cols.info:set("V2")
  509.         subtree:append_text(" Version 2")
  510.         subtree:add(buffer(0, 2), "Version: 0x0102")
  511.         subtree:add(buffer(2, 6), "<reserved>")
  512.         local count = buffer(8, 2):le_uint()
  513.         subtree:append_text((", total %u items"):format(count))
  514.         subtree:add(buffer(8, 2), ("Count: %u"):format(count))
  516.         local items, item_size = {}, 40
  517.         local item_offset, font_len, text_len = 10, 0, 0
  518.         for i = 1, count do
  519.             local item = {}
  520.             items[i] = item
  521.             local item_buffer = buffer(item_offset + (i - 1) * item_size, item_size)
  522.             item.len = item_buffer(0, 4):le_uint()
  523.             item.font_off, item.font_len = font_len, item_buffer(16, 4):le_uint()
  524.             item.text_off, item.text_len = text_len, item_buffer(36, 4):le_uint()
  525.             font_len = font_len + item.font_len
  526.             text_len = text_len + item.text_len
  527.         end
  528.         local text_offset = item_offset + count * item_size
  529.         local font_offset = text_offset + text_len
  530.         local pad_offset = font_offset + font_len
  531.         -- local item_segment = buffer(item_offset, count * item_size)
  532.         local text_segment = buffer(text_offset, text_len)
  533.         local font_segment = buffer(font_offset, font_len)
  535.         if count > 0 then
  536.             -- local subtree = subtree:add(item_segment, "Item Segment")
  537.             for i = 1, count do
  538.                 local item, item_string = items[i], ""
  539.                 local item_buffer = buffer(item_offset + (i - 1) * item_size, item_size)
  540.                 local item_tree = subtree:add(item_buffer, ("Item #%u"):format(i - 1))
  541.                 local font_buffer = font_segment:len() <= 0 and font_segment
  542.                     or font_segment(item.font_off, item.font_len)
  543.                 local text_buffer = text_segment:len() <= 0 and text_segment
  544.                     or text_segment(item.text_off, item.text_len)
  546.                 item_tree:add(item_buffer(0, 4), ("Len: %u"):format(item.len))
  547.                 item_tree:add(item_buffer(4, 4), ("Dir: %u"):format(item_buffer(4, 4):le_uint()))
  548.                 local pos_string = ("(%u/720,%u/576)"):format(item_buffer(8, 2):le_uint(), item_buffer(10, 2):le_uint())
  549.                 item_tree:add(item_buffer(8, 4), ("Pos: %s"):format(pos_string))
  550.                 item_string = item_string .. pos_string
  551.                 item_tree:add(item_buffer(12, 4), ("CodePage: %u"):format(item_buffer(12, 4):le_uint()))
  552.                 item_tree:add(item_buffer(16, 4), ("FontLen: %u"):format(item.font_len))
  553.                 if item.font_len > 0 then
  554.                     item_tree:add(font_buffer, ('Font: "%s"'):format(font_buffer:string(ENC_GB18030)))
  555.                 end
  556.                 item_tree:add(
  557.                     item_buffer(20, 4),
  558.                     ("CharSize: %ux%u"):format(item_buffer(20, 2):le_uint(), item_buffer(22, 2):le_uint())
  559.                 )
  560.                 local color_string = ("#%06X"):format(item_buffer(24, 4):le_uint())
  561.                 item_tree:add(item_buffer(24, 4), ("Color: %s"):format(color_string))
  562.                 item_string = item_string .. " " .. color_string
  563.                 item_tree:add(item_buffer(28, 4), ("Rotate: %u"):format(item_buffer(28, 4):le_uint()))
  564.                 item_tree:add(item_buffer(32, 4), ("PointSize: %u"):format(item_buffer(32, 4):le_uint()))
  565.                 item_tree:add(item_buffer(36, 4), ("TextLen: %u"):format(item.text_len))
  566.                 if item.text_len > 0 then
  567.                     local text_string = text_buffer:string(ENC_GB18030)
  568.                     item_tree:add(text_buffer, ('Text: "%s"'):format(text_string))
  569.                     item_string = item_string .. (' "%s"'):format(text_string)
  570.                 end
  572.                 item_tree:append_text((": %s"):format(item_string))
  573.                 pinfo.cols.info:append((", %s"):format(item_string))
  574.             end
  575.         end
  577.         if text_len > 0 then
  578.             -- local subtree = subtree:add(text_segment, "Text Segment")
  579.             for i = 1, count do
  580.                 local item = items[i]
  581.                 local text_buffer = text_segment(item.text_off, item.text_len)
  582.                 subtree:add(text_buffer, ('Text #%u: "%s"'):format(i - 1, text_buffer:string(ENC_GB18030)))
  583.             end
  584.         end
  586.         if font_len > 0 then
  587.             -- local subtree = subtree:add(font_segment, "FontName Segment")
  588.             for i = 1, count do
  589.                 local item = items[i]
  590.                 local font_buffer = font_segment(item.font_off, item.font_len)
  591.                 subtree:add(font_buffer, ('FontName #%u: "%s"'):format(i - 1, font_buffer:string(ENC_GB18030)))
  592.             end
  593.         end
  595.         if pad_offset < buffer:len() then
  596.             subtree:add(buffer(pad_offset, -1), "padding")
  597.         end
  598.     end
  600.     local function v3_dissector(buffer, pinfo, subtree)
  601.         pinfo.cols.protocol:set("Ws:Subt3")
  602.         pinfo.cols.info:set("V3")
  603.         subtree:append_text(" Version 3")
  604.         subtree:add(buffer(0, 2), "Version: 0x0103")
  605.         subtree:add(buffer(2, 6), "<reserved>")
  606.         local count = buffer(8, 2):le_uint()
  607.         subtree:append_text((", total %u items"):format(count))
  608.         subtree:add(buffer(8, 2), ("Count: %u"):format(count))
  610.         local items, item_size = {}, 26
  611.         local item_offset, font_len, text_len = 10, 0, 0
  612.         for i = 1, count do
  613.             local item = {}
  614.             items[i] = item
  615.             local item_buffer = buffer(item_offset + (i - 1) * item_size, item_size)
  616.             item.len = item_buffer(0, 2):le_uint()
  617.             item.font_off, item.font_len = font_len, item_buffer(10, 2):le_uint()
  618.             item.text_off, item.text_len = text_len, item_buffer(24, 2):le_uint()
  619.             font_len = font_len + item.font_len
  620.             text_len = text_len + item.text_len
  621.         end
  622.         local text_offset = item_offset + count * item_size
  623.         local font_offset = text_offset + text_len
  624.         local pad_offset = font_offset + font_len
  625.         -- local item_segment = buffer(item_offset, count * item_size)
  626.         local text_segment = buffer(text_offset, text_len)
  627.         local font_segment = buffer(font_offset, font_len)
  629.         if count > 0 then
  630.             -- local subtree = subtree:add(item_segment, "Item Segment")
  631.             for i = 1, count do
  632.                 local item, item_string = items[i], ""
  633.                 local item_buffer = buffer(item_offset + (i - 1) * item_size, item_size)
  634.                 local item_tree = subtree:add(item_buffer, ("Item #%u"):format(i - 1))
  635.                 local font_buffer = font_segment:len() <= 0 and font_segment
  636.                     or font_segment(item.font_off, item.font_len)
  637.                 local text_buffer = text_segment:len() <= 0 and text_segment
  638.                     or text_segment(item.text_off, item.text_len)
  640.                 item_tree:add(item_buffer(0, 2), ("Len: %u"):format(item.len))
  641.                 item_tree:add(item_buffer(2, 2), ("Dir: %u"):format(item_buffer(2, 2):le_uint()))
  642.                 local pos_string = ("(%.2f%%,%.2f%%)"):format(
  643.                     item_buffer(4, 2):le_uint() / 100,
  644.                     item_buffer(6, 2):le_uint() / 100
  645.                 )
  646.                 item_tree:add(item_buffer(4, 4), ("Pos: %s"):format(pos_string))
  647.                 item_string = item_string .. pos_string
  648.                 item_tree:add(item_buffer(8, 2), ("CodePage: %u"):format(item_buffer(8, 2):le_uint()))
  649.                 item_tree:add(item_buffer(10, 2), ("FontLen: %u"):format(item.font_len))
  650.                 if item.font_len > 0 then
  651.                     item_tree:add(font_buffer, ('Font: "%s"'):format(font_buffer:string(ENC_GB18030)))
  652.                 end
  653.                 item_tree:add(
  654.                     item_buffer(12, 4),
  655.                     ("CharSize: %ux%u"):format(item_buffer(12, 2):le_uint(), item_buffer(14, 2):le_uint())
  656.                 )
  657.                 local color_string = ("#%06X"):format(item_buffer(16, 4):le_uint())
  658.                 item_tree:add(item_buffer(16, 4), ("Color: %s"):format(color_string))
  659.                 item_string = item_string .. " " .. color_string
  660.                 item_tree:add(item_buffer(20, 2), ("Rotate: %u"):format(item_buffer(20, 2):le_uint()))
  661.                 item_tree:add(item_buffer(22, 2), ("PointSize: %u"):format(item_buffer(22, 2):le_uint()))
  662.                 item_tree:add(item_buffer(24, 2), ("TextLen: %u"):format(item.text_len))
  663.                 if item.text_len > 0 then
  664.                     local text_string = text_buffer:string(ENC_GB18030)
  665.                     item_tree:add(text_buffer, ('Text: "%s"'):format(text_string))
  666.                     item_string = item_string .. (' "%s"'):format(text_string)
  667.                 end
  669.                 item_tree:append_text((": %s"):format(item_string))
  670.                 pinfo.cols.info:append((", %s"):format(item_string))
  671.             end
  672.         end
  674.         if text_len > 0 then
  675.             -- local subtree = subtree:add(text_segment, "Text Segment")
  676.             for i = 1, count do
  677.                 local item = items[i]
  678.                 local text_buffer = text_segment(item.text_off, item.text_len)
  679.                 subtree:add(text_buffer, ('Text #%u: "%s"'):format(i - 1, text_buffer:string(ENC_GB18030)))
  680.             end
  681.         end
  683.         if font_len > 0 then
  684.             -- local subtree = subtree:add(font_segment, "FontName Segment")
  685.             for i = 1, count do
  686.                 local item = items[i]
  687.                 local font_buffer = font_segment(item.font_off, item.font_len)
  688.                 subtree:add(font_buffer, ('FontName #%u: "%s"'):format(i - 1, font_buffer:string(ENC_GB18030)))
  689.             end
  690.         end
  692.         if pad_offset < buffer:len() then
  693.             subtree:add(buffer(pad_offset, -1), "padding")
  694.         end
  695.     end
  697.     function proto.dissector(buffer, pinfo, tree)
  698.         local real_dissector = ({
  699.             [0x0102] = v2_dissector,
  700.             [0x0103] = v3_dissector,
  701.         })[buffer(0, 2):le_uint()] or v1_dissector
  703.         local subtree = tree:add(proto, buffer(), "WS Subtitle")
  704.         real_dissector(buffer, pinfo, subtree)
  705.     end
  706. end)
  708. -----------------------------------------------------------------------------
  710. local udp_table = DissectorTable.get("udp.port")
  711. udp_table:add(ws_proto.audio_port, ws_proto.audio)
  712. udp_table:add(ws_proto.video_port, ws_proto.video)
  713. udp_table:add(ws_proto.subtitle_port, ws_proto.subtitle)
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注