Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 808 insertions, 0 deletions

diff --git a/epan/dissectors/packet-daap.c b/epan/dissectors/packet-daap.c
new file mode 100644
index 00000000..22965b17
--- /dev/null
+++ b/epan/dissectors/packet-daap.c
@@ -0,0 +1,808 @@
+/* packet-daap.c
+ * Routines for Digital Audio Access Protocol dissection
+ * Copyright 2004, Kelly Byrd <kbyrd@memcpy.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/exceptions.h>
+#include <wsutil/str_util.h>
+#include <epan/expert.h>
+#include <epan/proto_data.h>
+#include "packet-http.h"
+
+#define TCP_PORT_DAAP 3689
+
+/* DAAP tags */
+/* Some information taken from http://tapjam.net/daap/ */
+/* and http://www.deleet.de/projekte/daap/?ContentCodes */
+/* DACP tags */
+/* Information from http://dacp.jsharkey.org/ */
+/* and http://code.google.com/p/tunesremote-plus/ */
+
+/* Container tags */
+#define daap_mcon       0x6d636f6e
+#define daap_msrv       0x6d737276
+#define daap_mccr       0x6d636372
+#define daap_mdcl       0x6d64636c
+#define daap_mlog       0x6d6c6f67
+#define daap_mupd       0x6d757064
+#define daap_avdb       0x61766462
+#define daap_mlcl       0x6d6c636c
+#define daap_mlit       0x6d6c6974
+#define daap_mbcl       0x6d62636c
+#define daap_adbs       0x61646273
+#define daap_aply       0x61706c79
+#define daap_apso       0x6170736f
+#define daap_mudl       0x6d75646c
+#define daap_abro       0x6162726f
+#define daap_abar       0x61626172
+#define daap_arsv       0x61727376
+#define daap_abal       0x6162616c
+#define daap_abcp       0x61626370
+#define daap_abgn       0x6162676e
+#define daap_prsv       0x70727376
+#define daap_arif       0x61726966
+#define daap_mctc       0x6d637463
+#define dacp_casp       0x63617370
+#define dacp_cmst       0x636d7374
+#define dacp_cmgt       0x636d6774
+/* String tags */
+#define daap_minm       0x6d696e6d
+#define daap_msts       0x6d737473
+#define daap_mcnm       0x6d636e6d
+#define daap_mcna       0x6d636e61
+#define daap_asal       0x6173616c
+#define daap_asar       0x61736172
+#define daap_ascm       0x6173636d
+#define daap_asfm       0x6173666d
+#define daap_aseq       0x61736571
+#define daap_asgn       0x6173676e
+#define daap_asdt       0x61736474
+#define daap_asul       0x6173756c
+#define daap_ascp       0x61736370
+#define daap_asct       0x61736374
+#define daap_ascn       0x6173636e
+#define daap_aslc       0x61736c63
+#define daap_asky       0x61736b79
+#define daap_aeSN       0x6165534e
+#define daap_aeNN       0x61654e4e
+#define daap_aeEN       0x6165454e
+#define daap_assn       0x6173736e
+#define daap_assa       0x61737361
+#define daap_assl       0x6173736c
+#define daap_assc       0x61737363
+#define daap_asss       0x61737373
+#define daap_asaa       0x61736161
+#define daap_aspu       0x61737075
+#define daap_aeCR       0x61654352
+#define dacp_cana       0x63616e61
+#define dacp_cang       0x63616e67
+#define dacp_canl       0x63616e6c
+#define dacp_cann       0x63616e6e
+
+/* uint64 tags */
+#define daap_mper       0x6d706572
+#define daap_aeGU       0x61654755
+#define daap_aeGR       0x61654752
+#define daap_asai       0x61736169
+#define daap_asls       0x61736c73
+
+/* uint32 tags */
+#define daap_mstt       0x6d737474
+#define daap_musr       0x6d757372
+#define daap_miid       0x6d696964
+#define daap_mcti       0x6d637469
+#define daap_mpco       0x6d70636f
+#define daap_mimc       0x6d696d63
+#define daap_mrco       0x6d72636f
+#define daap_mtco       0x6d74636f
+#define daap_mstm       0x6d73746d
+#define daap_msdc       0x6d736463
+#define daap_mlid       0x6d6c6964
+#define daap_msur       0x6d737572
+#define daap_asda       0x61736461
+#define daap_asdm       0x6173646d
+#define daap_assr       0x61737372
+#define daap_assz       0x6173737a
+#define daap_asst       0x61737374
+#define daap_assp       0x61737370
+#define daap_astm       0x6173746d
+#define daap_aeNV       0x61654e56
+#define daap_ascd       0x61736364
+#define daap_ascs       0x61736373
+#define daap_aeSV       0x61655356
+#define daap_aePI       0x61655049
+#define daap_aeCI       0x61654349
+#define daap_aeGI       0x61654749
+#define daap_aeAI       0x61654149
+#define daap_aeSI       0x61655349
+#define daap_aeES       0x61654553
+#define daap_aeSU       0x61655355
+#define daap_asbo       0x6173626f
+#define daap_aeGH       0x61654748
+#define daap_aeGD       0x61654744
+#define daap_aeGE       0x61654745
+#define daap_meds       0x6d656473
+#define dacp_cmsr       0x636d7372
+#define dacp_cant       0x63616e74
+#define dacp_cast       0x63617374
+#define dacp_cmvo       0x636d766f
+/*TODO:
+#define daap_msto               0x6d7374OO utcoffset
+*/
+/* uint16 tags */
+#define daap_mcty       0x6d637479
+#define daap_asbt       0x61736274
+#define daap_asbr       0x61736272
+#define daap_asdc       0x61736463
+#define daap_asdn       0x6173646e
+#define daap_astc       0x61737463
+#define daap_astn       0x6173746e
+#define daap_asyr       0x61737972
+#define daap_ased       0x61736564
+/* byte  tags */
+#define daap_mikd       0x6d696b64
+#define daap_msau       0x6d736175
+#define daap_msty       0x6d737479
+#define daap_asrv       0x61737276 /* XXX: may be uint16 in newer iTunes versions! */
+#define daap_asur       0x61737572
+#define daap_asdk       0x6173646b
+#define daap_muty       0x6d757479
+#define daap_msas       0x6d736173
+#define daap_aeHV       0x61654856
+#define daap_aeHD       0x61654844
+#define daap_aePC       0x61655043
+#define daap_aePP       0x61655050
+#define daap_aeMK       0x61654d4b
+#define daap_aeSG       0x61655347
+#define daap_apsm       0x6170736d
+#define daap_aprm       0x6170726d
+#define daap_asgp       0x61736770
+#define daap_aePS       0x61655053
+#define daap_asbk       0x6173626b
+#define dacp_cafs       0x63616673
+#define dacp_caps       0x63617073
+#define dacp_carp       0x63617270
+#define dacp_cash       0x63617368
+#define dacp_cavs       0x63617673
+/* boolean  tags */
+#define daap_mslr       0x6d736c72
+#define daap_msal       0x6d73616c
+#define daap_msup       0x6d737570
+#define daap_mspi       0x6d737069
+#define daap_msex       0x6d736578
+#define daap_msbr       0x6d736272
+#define daap_msqy       0x6d737179
+#define daap_msix       0x6d736978
+#define daap_msrs       0x6d737273
+#define daap_asco       0x6173636f
+#define daap_asdb       0x61736462
+#define daap_abpl       0x6162706c
+#define daap_aeSP       0x61655350
+#define daap_ashp       0x61736870
+/* version (32-bit)*/
+#define daap_mpro       0x6d70726f
+#define daap_apro       0x6170726f
+/* now playing */
+#define dacp_canp       0x63616e70
+
+#define daap_png        0x89504e47
+/* date/time */
+/* TODO:
+#define daap_mstc 0xMMSSTTCC utctime
+#define daap_asdr ("daap.songdatereleased")
+#define daap_asdp ("daap.songdatepurchased")
+*/
+
+void proto_register_daap(void);
+void proto_reg_handoff_daap(void);
+
+static dissector_handle_t daap_handle;
+
+static dissector_handle_t png_handle;
+
+/*XXX: Sorted by value definition since it appears that the "value" is just */
+/*     the ascii representation of the last 4 letters of the definition.    */
+/*     (Sorted so a binary search can be done when using value_string_ext)  */
+static const value_string vals_tag_code[] = {
+   { daap_abal, "browse album listing" },
+   { daap_abar, "browse artist listing" },
+   { daap_abcp, "browse composer listing" },
+   { daap_abgn, "browse genre listing" },
+   { daap_abpl, "base playlist" },
+   { daap_abro, "database browse" },
+   { daap_adbs, "database songs" },
+   { daap_aeAI, "com.apple.itunes.itms-artistid" },
+   { daap_aeCI, "com.apple.itunes.itms-composerid" },
+   { daap_aeCR, "com.apple.itunes.content-rating" },
+   { daap_aeEN, "com.apple.itunes.episode-num-str" },
+   { daap_aeES, "com.apple.itunes.episode-sort" },
+   { daap_aeGD, "com.apple.itunes.gapless-enc-dr" },
+   { daap_aeGE, "com.apple.itunes.gapless-enc-del" },
+   { daap_aeGH, "com.apple.itunes.gapless-heur" },
+   { daap_aeGI, "com.apple.itunes.itms-genreid" },
+   { daap_aeGR, "com.apple.itunes.gapless-resy" },
+   { daap_aeGU, "com.apple.itunes.gapless-dur" },
+   { daap_aeHD, "com.apple.itunes.is-hd-video" },
+   { daap_aeHV, "com.apple.itunes.has-video" },
+   { daap_aeMK, "com.apple.itunes.mediakind" },
+   { daap_aeNN, "com.apple.itunes.network-name" },
+   { daap_aeNV, "com.apple.itunes.norm-volume" },
+   { daap_aePC, "com.apple.itunes.is-podcast" },
+   { daap_aePI, "com.apple.itunes.itms-playlistid" },
+   { daap_aePP, "com.apple.itunes.is-podcast-playlist" },
+   { daap_aePS, "com.apple.itunes.special-playlist" },
+   { daap_aeSG, "com.apple.itunes.saved-genius" },
+   { daap_aeSI, "com.apple.itunes.itms-songid" },
+   { daap_aeSN, "com.apple.itunes.series-name" },
+   { daap_aeSP, "com.apple.itunes.smart-playlist" },
+   { daap_aeSU, "com.apple.itunes.season-num" },
+   { daap_aeSV, "com.apple.itunes.music-sharing-version" },
+   { daap_aply, "database playlists" },
+   { daap_aprm, "playlist repeat mode" },
+   { daap_apro, "protocol (application?) version (apro)" },
+   { daap_apsm, "playlist shuffle mode" },
+   { daap_apso, "playlist songs" },
+   { daap_arif, "resolveinfo" },
+   { daap_arsv, "resolve" },
+   { daap_asaa, "song album artist" },
+   { daap_asai, "song album id"},
+   { daap_asal, "song album" },
+   { daap_asar, "song artist" },
+   { daap_asbk, "song bookmarkable" },
+   { daap_asbo, "song bookmark" },
+   { daap_asbr, "song bitrate" },
+   { daap_asbt, "song beats-per-minute" },
+   { daap_ascd, "song codec type" },
+   { daap_ascm, "song comment" },
+   { daap_ascn, "song content description" },
+   { daap_asco, "song compilation" },
+   { daap_ascp, "song composer" },
+   { daap_ascs, "song codec subtype" },
+   { daap_asct, "song category" },
+   { daap_asda, "song date added" },
+   { daap_asdb, "song disabled" },
+   { daap_asdc, "song disccount" },
+   { daap_asdk, "song data kind" },
+   { daap_asdm, "song date modified" },
+   { daap_asdn, "song discnumber" },
+   { daap_asdt, "song description" },
+   { daap_ased, "song extra data" },
+   { daap_aseq, "song eq preset" },
+   { daap_asfm, "song format" },
+   { daap_asgn, "song genre" },
+   { daap_asgp, "song gapless" },
+   { daap_ashp, "song has been played" },
+   { daap_asky, "song keywords" },
+   { daap_aslc, "song long content description" },
+   { daap_asls, "song long size"},
+   { daap_aspu, "song podcast url" },
+   { daap_asrv, "song relative volume" },
+   { daap_assa, "sort artist" },
+   { daap_assc, "sort composer" },
+   { daap_assn, "sort name" },
+   { daap_assp, "song stop time (milliseconds)" },
+   { daap_assr, "song sample rate" },
+   { daap_asss, "sort seriesname" },
+   { daap_asst, "song start time (milliseconds)" },
+   { daap_assz, "song size" },
+   { daap_astc, "song track count" },
+   { daap_astm, "song time (milliseconds)" },
+   { daap_astn, "song track number" },
+   { daap_asul, "song data url" },
+   { daap_asur, "song user rating" },
+   { daap_asyr, "song year" },
+   { daap_avdb, "server databases" },
+   { dacp_cafs, "fullscreen" },
+   { dacp_cana, "song artist" },
+   { dacp_cang, "song genre" },
+   { dacp_canl, "song album" },
+   { dacp_cann, "song name" },
+   { dacp_canp, "now playing" },
+   { dacp_cant, "song time remaining (milliseconds)" },
+   { dacp_caps, "play status" },
+   { dacp_carp, "repeat" },
+   { dacp_cash, "shuffle" },
+   { dacp_casp, "speakers container" },
+   { dacp_cast, "song time total (milliseconds)" },
+   { dacp_cavs, "visualizer" },
+   { dacp_cmgt, "container (cmgt)" },
+   { dacp_cmsr, "status revision" },
+   { dacp_cmst, "control container" },
+   { dacp_cmvo, "volume" },
+   { daap_mbcl, "bag (mbcl)" },
+   { daap_mccr, "content codes response" },
+   { daap_mcna, "content codes name" },
+   { daap_mcnm, "content codes number" },
+   { daap_mcon, "container (mcon)" },
+   { daap_mctc, "container count" },
+   { daap_mcti, "container item id (mcti)" },
+   { daap_mcty, "content codes type" },
+   { daap_mdcl, "dictionary (mdcl)" },
+   { daap_meds, "edit commands supported" },
+   { daap_miid, "item id (miid)" },
+   { daap_mikd, "item kind (mikd)" },
+   { daap_mimc, "item count (mimc)" },
+   { daap_minm, "item name (minm)" },
+   { daap_mlcl, "listing (mlcl)" },
+   { daap_mlid, "session id" },
+   { daap_mlit, "listing item (mlit)" },
+   { daap_mlog, "login response" },
+   { daap_mpco, "parent container id (mpco)" },
+   { daap_mper, "persistent id (mper)" },
+   { daap_mpro, "protocol version (mpro)" },
+   { daap_mrco, "returned count (mrco)" },
+   { daap_msal, "supports auto-logout (msal)" },
+   { daap_msas, "authentication schemes" },
+   { daap_msau, "authentication method (msau)" },
+   { daap_msbr, "supports browse" },
+   { daap_msdc, "databases count" },
+   { daap_msex, "supports extensions (msex)" },
+   { daap_msix, "supports index" },
+   { daap_mslr, "login required (mslr)" },
+   { daap_mspi, "supports persistent ids (mspi)" },
+   { daap_msqy, "supports query" },
+   { daap_msrs, "supports resolve" },
+   { daap_msrv, "server info response (msrv)" },
+   { daap_mstm, "timeout interval" },
+   { daap_msts, "status string (msts)" },
+   { daap_mstt, "status (mstt)" },
+   { daap_msup, "supports update (msup)" },
+   { daap_msur, "server revision" },
+   { daap_mtco, "specified total count (mtco)" },
+   { daap_mudl, "deleted id listing" },
+   { daap_mupd, "update response" },
+   { daap_musr, "server revision" },
+   { daap_muty, "update type" },
+   { daap_prsv, "resolve" },
+   { 0,         NULL}
+};
+static value_string_ext vals_tag_code_ext = VALUE_STRING_EXT_INIT(vals_tag_code);
+
+/* Initialize the protocol and registered fields */
+static int proto_daap = -1;
+static int hf_daap_name = -1;
+static int hf_daap_size = -1;
+static int hf_daap_data_string = -1;
+static int hf_daap_persistent_id = -1;
+static int hf_daap_status = -1;
+static int hf_daap_rev = -1;
+static int hf_daap_id = -1;
+static int hf_daap_cnt = -1;
+static int hf_daap_timeout = -1;
+static int hf_daap_data = -1;
+static int hf_daap_playlist_id = -1;
+static int hf_daap_track_id = -1;
+
+/* Initialize the subtree pointers */
+static gint ett_daap = -1;
+static gint ett_daap_sub = -1;
+
+static expert_field ei_daap_max_recursion_depth_reached = EI_INIT;
+
+/* Forward declarations */
+static void dissect_daap_one_tag(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb);
+
+static int
+dissect_daap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+   proto_item *ti;
+   proto_tree *daap_tree;
+   guint first_tag;
+
+   first_tag = tvb_get_ntohl(tvb, 0);
+   col_set_str(pinfo->cinfo, COL_PROTOCOL, "DAAP");
+
+   /*
+    * This catches album art coming back from iTunes.
+    * XXX - will those have a media type of image/png
+    * rather than application/x-dmap-tagged?  If so,
+    * this is no longer necessary.
+    */
+   if (first_tag == daap_png) {
+      call_dissector(png_handle, tvb, pinfo, tree);
+      return tvb_captured_length(tvb);
+   }
+
+   /* This is done in two functions on purpose. If the tvb_get_xxx()
+    * functions fail, at least something will be in the info column
+    */
+   col_set_str(pinfo->cinfo, COL_INFO, "DAAP Response");
+   col_append_fstr(pinfo->cinfo, COL_INFO, " [first tag: %s, size: %d]",
+                   tvb_format_text(pinfo->pool, tvb, 0, 4),
+                   tvb_get_ntohl(tvb, 4));
+
+   ti = proto_tree_add_item(tree, proto_daap, tvb, 0, -1, ENC_NA);
+   daap_tree = proto_item_add_subtree(ti, ett_daap);
+   dissect_daap_one_tag(daap_tree, pinfo, tvb);
+   return tvb_captured_length(tvb);
+}
+
+#define DAAP_MAX_RECURSION_DEPTH 100
+
+static void
+dissect_daap_one_tag(proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb)
+{
+   guint       offset = 0;
+   guint32     tagname, tagsize;
+   proto_item *tag_ti;
+   proto_tree *tag_tree;
+   tvbuff_t   *new_tvb;
+   unsigned    recursion_depth = p_get_proto_depth(pinfo, proto_daap);
+
+   if (++recursion_depth >= DAAP_MAX_RECURSION_DEPTH) {
+      proto_tree_add_expert(tree, pinfo, &ei_daap_max_recursion_depth_reached,
+                            tvb, 0, 0);
+      return;
+   }
+   p_set_proto_depth(pinfo, proto_daap, recursion_depth);
+
+   while (offset < tvb_reported_length(tvb)) {
+      tagname = tvb_get_ntohl(tvb, offset);
+      tagsize = tvb_get_ntohl(tvb, offset+4);
+
+      tag_tree = proto_tree_add_subtree(tree, tvb, offset, -1,
+            ett_daap_sub, &tag_ti, "Tag: ");
+
+      proto_tree_add_item_ret_uint(tag_tree, hf_daap_name,
+            tvb, offset, 4, ENC_ASCII|ENC_NA, &tagname);
+      offset += 4;
+      proto_tree_add_item_ret_uint(tag_tree, hf_daap_size,
+            tvb, offset, 4, ENC_BIG_ENDIAN, &tagsize);
+      offset += 4;
+
+      proto_item_append_text(tag_ti, "%s, %u byte%c",
+            val_to_str_ext(tagname, &vals_tag_code_ext, "Unknown tag (0x%0x)"),
+            tagsize, plurality(tagsize, ' ', 's'));
+      proto_item_set_len(tag_ti, 8+tagsize);
+
+      if (tagsize > G_MAXINT)
+         break;
+
+      switch (tagname) {
+         case daap_mcon:
+         case daap_msrv:
+         case daap_mccr:
+         case daap_mdcl:
+         case daap_mlog:
+         case daap_mupd:
+         case daap_avdb:
+         case daap_mlcl:
+         case daap_mlit:
+         case daap_mbcl:
+         case daap_adbs:
+         case daap_aply:
+         case daap_apso:
+         case daap_mudl:
+         case daap_abro:
+         case daap_abar:
+         case daap_arsv:
+         case daap_abal:
+         case daap_abcp:
+         case daap_abgn:
+         case daap_prsv:
+         case daap_arif:
+         case dacp_casp:
+         case dacp_cmgt:
+         case dacp_cmst:
+            /* Container tags */
+            new_tvb  = tvb_new_subset_length(tvb, offset, (gint)tagsize);
+            dissect_daap_one_tag(tag_tree, pinfo, new_tvb);
+            break;
+
+         case daap_minm:
+         case daap_msts:
+         case daap_mcnm:
+         case daap_mcna:
+         case daap_asal:
+         case daap_asar:
+         case daap_ascm:
+         case daap_asfm:
+         case daap_aseq:
+         case daap_asgn:
+         case daap_asdt:
+         case daap_asul:
+         case daap_ascp:
+         case daap_asct:
+         case daap_ascn:
+         case daap_aslc:
+         case daap_asky:
+         case daap_aeSN:
+         case daap_aeNN:
+         case daap_aeEN:
+         case daap_assn:
+         case daap_assa:
+         case daap_assl:
+         case daap_assc:
+         case daap_asss:
+         case daap_asaa:
+         case daap_aspu:
+         case daap_aeCR:
+         case dacp_cana:
+         case dacp_cang:
+         case dacp_canl:
+         case dacp_cann:
+            /* Tags contain strings
+               XXX - verify that they're really 7bit ASCII */
+            proto_tree_add_item(tag_tree, hf_daap_data_string,
+                  tvb, offset, tagsize, ENC_ASCII);
+            break;
+
+         case daap_mper:
+         case daap_aeGR:
+         case daap_aeGU:
+         case daap_asai:
+         case daap_asls:
+            proto_tree_add_item(tag_tree, hf_daap_persistent_id,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mstt:
+            proto_tree_add_item(tag_tree, hf_daap_status,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_musr:
+         case daap_msur:
+            proto_tree_add_item(tag_tree, hf_daap_rev,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_miid:
+         case daap_mcti:
+         case daap_mpco:
+         case daap_mlid:
+            proto_tree_add_item(tag_tree, hf_daap_id,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mrco:
+         case daap_mtco:
+         case daap_mimc:
+         case daap_msdc:
+         case daap_mctc:
+            proto_tree_add_item(tag_tree, hf_daap_cnt,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mstm:
+            proto_tree_add_item(tag_tree, hf_daap_timeout,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_asda:
+         case daap_asdm:
+         case daap_assr:
+         case daap_assz:
+         case daap_asst:
+         case daap_assp:
+         case daap_astm:
+         case daap_aeNV:
+         case daap_ascd:
+         case daap_ascs:
+         case daap_aeSV:
+         case daap_aePI:
+         case daap_aeCI:
+         case daap_aeGI:
+         case daap_aeAI:
+         case daap_aeSI:
+         case daap_aeES:
+         case daap_asbo:
+         case daap_aeGH:
+         case daap_aeGD:
+         case daap_aeGE:
+         case dacp_cant:
+         case dacp_cast:
+         case dacp_cmsr:
+         case dacp_cmvo:
+         case daap_meds:
+            /* Tags contain uint32
+               XXX - check tagsize here and below */
+            proto_tree_add_item(tag_tree, hf_daap_data,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mcty:
+         case daap_asbt:
+         case daap_asbr:
+         case daap_asdc:
+         case daap_asdn:
+         case daap_astc:
+         case daap_astn:
+         case daap_asyr:
+         case daap_ased:
+            /* Tags contain uint16 */
+            proto_tree_add_item(tag_tree, hf_daap_data,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mikd:
+         case daap_msau:
+         case daap_msty:
+         case daap_asrv:
+         case daap_asur:
+         case daap_asdk:
+         case daap_muty:
+         case daap_msas:
+         case daap_aeHV:
+         case daap_aeHD:
+         case daap_aePC:
+         case daap_aePP:
+         case daap_aeMK:
+         case daap_aeSG:
+         case daap_apsm:
+         case daap_aprm:
+         case daap_asgp:
+         case daap_aePS:
+         case dacp_cafs:
+         case dacp_caps:
+         case dacp_carp:
+         case dacp_cash:
+         case dacp_cavs:
+            /* Tags contain uint8 */
+            proto_tree_add_item(tag_tree, hf_daap_data,
+                  tvb, offset, tagsize, ENC_BIG_ENDIAN);
+            break;
+
+         case daap_mslr:
+         case daap_msal:
+         case daap_msup:
+         case daap_mspi:
+         case daap_msex:
+         case daap_msbr:
+         case daap_msqy:
+         case daap_msix:
+         case daap_msrs:
+         case daap_asco:
+         case daap_asdb:
+         case daap_abpl:
+         case daap_aeSP:
+         case daap_asbk:
+            /* Tags ARE boolean. Data is (uint8), but it seems
+             * the value is always zero. So, if the tag is present
+             * the "bool" is true.
+             */
+            proto_item_append_text(tag_ti, "; Data: True");
+            break;
+
+         case daap_mpro:
+         case daap_apro:
+            /* Tags contain version (uint32) */
+            proto_item_append_text(tag_ti, "; Version: %d.%d.%d.%d",
+                  tvb_get_guint8(tvb, offset),
+                  tvb_get_guint8(tvb, offset+1),
+                  tvb_get_guint8(tvb, offset+2),
+                  tvb_get_guint8(tvb, offset+3));
+            break;
+
+         case dacp_canp:
+            /* now playing */
+            /* bytes  4-7  contain uint32 playlist id */
+            /* bytes 12-15 contain uint32 track id */
+
+            proto_tree_add_item(tag_tree, hf_daap_playlist_id,
+                  tvb, offset+4, 4, ENC_BIG_ENDIAN);
+            proto_tree_add_item(tag_tree, hf_daap_track_id,
+                  tvb, offset+12, 4, ENC_BIG_ENDIAN);
+            break;
+
+         default:
+            break;
+      }
+
+      offset += tagsize;
+   }
+}
+
+
+/* Register the protocol with Wireshark */
+void
+proto_register_daap(void)
+{
+
+   static hf_register_info hf[] = {
+      { &hf_daap_name,
+        { "Tag name", "daap.name", FT_UINT32,
+           BASE_HEX|BASE_EXT_STRING, &vals_tag_code_ext, 0, NULL, HFILL }
+      },
+      { &hf_daap_size,
+        { "Tag size", "daap.size",
+           FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_data_string,
+        { "Data string", "daap.data_string",
+           FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_persistent_id,
+        { "Persistent Id", "daap.persistent_id",
+           FT_UINT64, BASE_HEX, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_status,
+        { "Status", "daap.status",
+           FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_rev,
+        { "Revision", "daap.revision",
+           FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_id,
+        { "Id", "daap.id",
+           FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_cnt,
+        { "Count", "daap.count",
+           FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_timeout,
+        { "Timeout (seconds)", "daap.timeout",
+           FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }
+      },
+      /* this will hold data for the tags that contain
+         32, 16 or 8 bits of payload */
+      { &hf_daap_data,
+        { "Data", "daap.data",
+           FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_playlist_id,
+        { "Playlist Id", "daap.playlist_id",
+           FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
+      },
+      { &hf_daap_track_id,
+        { "Track Id", "daap.track_id",
+           FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }
+      }
+   };
+
+   static gint *ett[] = {
+      &ett_daap,
+      &ett_daap_sub,
+   };
+
+   expert_module_t *expert_daap;
+
+   static ei_register_info ei[] = {
+      { &ei_daap_max_recursion_depth_reached, { "daap.max_recursion_depth_reached",
+        PI_PROTOCOL, PI_WARN, "Maximum allowed recursion depth reached - stop decoding", EXPFILL }}
+   };
+
+   proto_daap = proto_register_protocol("Digital Audio Access Protocol",
+                                        "DAAP", "daap");
+
+   expert_daap = expert_register_protocol(proto_daap);
+   expert_register_field_array(expert_daap, ei, array_length(ei));
+
+   proto_register_field_array(proto_daap, hf, array_length(hf));
+   proto_register_subtree_array(ett, array_length(ett));
+
+   daap_handle = register_dissector("daap", dissect_daap, proto_daap);
+}
+
+void
+proto_reg_handoff_daap(void)
+{
+   http_tcp_port_add(TCP_PORT_DAAP);
+   dissector_add_string("media_type", "application/x-dmap-tagged", daap_handle);
+
+   png_handle = find_dissector_add_dependency("png", proto_daap);
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local Variables:
+ * c-basic-offset: 3
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=3 tabstop=8 expandtab:
+ * :indentSize=3:tabSize=8:noTabs=true:
+ */