/* packet-mrcpv2.c

 * Routines for Media Resource Control Protocol Version 2 (MRCPv2) dissection

 * Copyright 2012, Zeljko Ancimer  <zancimer[AT]gmail.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/*

 * Based on RFC 6787

 *

 * TODO:

 * - TLS has not been tested

 * - MRCP conversation (similar to VoIP Calls)

 * - convert header value into the correct types (numbers, booleans,...);

 *   currently all values are treated as strings so one has to be

 *   careful with the usage of filters; to do this, one has to go through

 *   the mrcp draft and look for the definition of each header (see

 *   chapter titled "15. ABNF Normative Definition")

 */

#include "config.h"

/* Include only as needed */

#include <stdlib.h>

#include <epan/packet.h>

#include <epan/expert.h>

#include "packet-tcp.h"

#include <wsutil/str_util.h>

#include <wsutil/strtoi.h>

void proto_register_mrcpv2(void);

void proto_reg_handoff_mrcpv2(void);

static dissector_handle_t mrcpv2_handle;

/* mrcp-version SP message-length */

/*   mrcp-version = "MRCP" "/" 1*2DIGIT "." 1*2DIGIT  ==> up to 10 chars */

/*   SP ==> whitespace, 1 char */

/*   message-length = 1*19DIGIT  ==> up to 19 chars */

/*   total = 10 + 1 + 19 = 30 */

/* min length to determine MRCPv2 version */

#define MRCPV2_MIN_LENGTH    10

/* min length to determine MRCPv2 PDU length */

#define MRCPV2_MIN_PDU_LEN   30

/* line type */

typedef enum {

    REQUEST_LINE,

    RESPONSE_LINE,

    EVENT_LINE,

    UNKNOWN_LINE

} LINE_TYPE;

/* header type */

typedef enum {

    UNKNOWN =                               0,

    ABORT_MODEL =                           1,

    ABORT_PHRASE_ENROLLMENT =               2,

    ABORT_VERIFICATION =                    3,

    ACCEPT =                                4,

    ACCEPT_CHARSET =                        5,

    ACTIVE_REQUEST_ID_LIST =                6,

    ADAPT_MODEL =                           7,

    AUDIO_FETCH_HINT =                      8,

    CACHE_CONTROL =                         9,

    CANCEL_IF_QUEUE =                       10,

    CAPTURE_ON_SPEECH =                     11,

    CHANNEL_IDENTIFIER =                    12,

    CLASH_THRESHOLD =                       13,

    CLEAR_DTMF_BUFFER =                     14,

    COMPLETION_CAUSE =                      15,

    COMPLETION_REASON =                     16,

    CONFIDENCE_THRESHOLD =                  17,

    CONFUSABLE_PHRASES_URI =                18,

    CONSISTENCY_THRESHOLD =                 19,

    CONTENT_BASE =                          20,

    CONTENT_ENCODING =                      21,

    CONTENT_ID =                            22,

    CONTENT_LENGTH =                        23,

    CONTENT_LOCATION =                      24,

    CONTENT_TYPE =                          25,

    DTMF_BUFFER_TIME =                      26,

    DTMF_INTERDIGIT_TIMEOUT =               27,

    DTMF_TERM_CHAR =                        28,

    DTMF_TERM_TIMEOUT =                     29,

    EARLY_NO_MATCH =                        30,

    ENROLL_UTTERANCE =                      31,

    FAILED_URI =                            32,

    FAILED_URI_CAUSE =                      33,

    FETCH_HINT =                            34,

    FETCH_TIMEOUT =                         35,

    FINAL_SILENCE =                         36,

    HOTWORD_MAX_DURATION =                  37,

    HOTWORD_MIN_DURATION =                  38,

    INPUT_TYPE =                            39,

    INPUT_WAVEFORM_URI =                    40,

    INTERPRET_TEXT =                        41,

    JUMP_SIZE =                             42,

    KILL_ON_BARGE_IN =                      43,

    LEXICON_SEARCH_ORDER =                  44,

    LOAD_LEXICON =                          45,

    LOGGING_TAG =                           46,

    MAX_TIME =                              47,

    MEDIA_TYPE =                            48,

    MIN_VERIFICATION_SCORE =                49,

    N_BEST_LIST_LENGTH =                    50,

    NEW_AUDIO_CHANNEL =                     51,

    NEW_PHRASE_ID =                         52,

    NO_INPUT_TIMEOUT =                      53,

    NUM_MAX_VERIFICATION_PHRASES =          54,

    NUM_MIN_CONSISTENT_PRONUNCIATIONS =     55,

    NUM_MIN_VERIFICATION_PHRASES =          56,

    PERSONAL_GRAMMAR_URI =                  57,

    PHRASE_ID =                             58,

    PHRASE_NL =                             59,

    PROSODY_CONTOUR =                       60,

    PROSODY_DURATION =                      61,

    PROSODY_PITCH =                         62,

    PROSODY_RANGE =                         63,

    PROSODY_RATE =                          64,

    PROSODY_VOLUME =                        65,

    PROXY_SYNC_ID =                         66,

    RECOGNITION_MODE =                      67,

    RECOGNITION_TIMEOUT =                   68,

    RECOGNIZER_CONTEXT_BLOCK =              69,

    RECORD_URI =                            70,

    REPOSITORY_URI =                        71,

    SAVE_BEST_WAVEFORM =                    72,

    SAVE_WAVEFORM =                         73,

    SENSITIVITY_LEVEL =                     74,

    SET_COOKIE =                            75,

    SPEAK_LENGTH =                          76,

    SPEAK_RESTART =                         77,

    SPEAKER_PROFILE =                       78,

    SPEECH_COMPLETE_TIMEOUT =               79,

    SPEECH_INCOMPLETE_TIMEOUT =             80,

    SPEECH_LANGUAGE =                       81,

    SPEECH_MARKER =                         82,

    SPEED_VS_ACCURACY =                     83,

    START_INPUT_TIMERS =                    84,

    TRIM_LENGTH =                           85,

    VENDOR_SPECIFIC_PARAMETERS =            86,

    VER_BUFFER_UTTERANCE =                  87,

    VERIFICATION_MODE =                     88,

    VOICE_AGE =                             89,

    VOICE_GENDER =                          90,

    VOICE_NAME =                            91,

    VOICE_VARIANT =                         92,

    VOICEPRINT_EXISTS =                     93,

    VOICEPRINT_IDENTIFIER =                 94,

    WAVEFORM_URI =                          95,

    WEIGHT =                                96

} HEADER_TYPE;

static const value_string header_type_vals[] = {

    { ABORT_MODEL,                          "abort-model" },

    { ABORT_PHRASE_ENROLLMENT,              "abort-phrase-enrollment" },

    { ABORT_VERIFICATION,                   "abort-verification" },

    { ACCEPT,                               "accept" },

    { ACCEPT_CHARSET,                       "accept-charset" },

    { ACTIVE_REQUEST_ID_LIST,               "active-request-id-list" },

    { ADAPT_MODEL,                          "adapt-model" },

    { AUDIO_FETCH_HINT,                     "audio-fetch-hint" },

    { CACHE_CONTROL,                        "cache-control" },

    { CANCEL_IF_QUEUE,                      "cancel-if-queue" },

    { CAPTURE_ON_SPEECH,                    "capture-on-speech" },

    { CHANNEL_IDENTIFIER,                   "channel-identifier" },

    { CLASH_THRESHOLD,                      "clash-threshold" },

    { CLEAR_DTMF_BUFFER,                    "clear-dtmf-buffer" },

    { COMPLETION_CAUSE,                     "completion-cause" },

    { COMPLETION_REASON,                    "completion-reason" },

    { CONFIDENCE_THRESHOLD,                 "confidence-threshold" },

    { CONFUSABLE_PHRASES_URI,               "confusable-phrases-uri" },

    { CONSISTENCY_THRESHOLD,                "consistency-threshold" },

    { CONTENT_BASE,                         "content-base" },

    { CONTENT_ENCODING,                     "content-encoding" },

    { CONTENT_ID,                           "content-id" },

    { CONTENT_LENGTH,                       "content-length" },

    { CONTENT_LOCATION,                     "content-location" },

    { CONTENT_TYPE,                         "content-type" },

    { DTMF_BUFFER_TIME,                     "dtmf-buffer-time" },

    { DTMF_INTERDIGIT_TIMEOUT,              "dtmf-interdigit-timeout" },

    { DTMF_TERM_CHAR,                       "dtmf-term-char" },

    { DTMF_TERM_TIMEOUT,                    "dtmf-term-timeout" },

    { EARLY_NO_MATCH,                       "early-no-match" },

    { ENROLL_UTTERANCE,                     "enroll-utterance" },

    { FAILED_URI,                           "failed-uri" },

    { FAILED_URI_CAUSE,                     "failed-uri-cause" },

    { FETCH_HINT,                           "fetch-hint" },

    { FETCH_TIMEOUT,                        "fetch-timeout" },

    { FINAL_SILENCE,                        "final-silence" },

    { HOTWORD_MAX_DURATION,                 "hotword-max-duration" },

    { HOTWORD_MIN_DURATION,                 "hotword-min-duration" },

    { INPUT_TYPE,                           "input-type" },

    { INPUT_WAVEFORM_URI,                   "input-waveform-uri" },

    { INTERPRET_TEXT,                       "interpret-text" },

    { JUMP_SIZE,                            "jump-size" },

    { KILL_ON_BARGE_IN,                     "kill-on-barge-in" },

    { LEXICON_SEARCH_ORDER,                 "lexicon-search-order" },

    { LOAD_LEXICON,                         "load-lexicon" },

    { LOGGING_TAG,                          "logging-tag" },

    { MAX_TIME,                             "max-time" },

    { MEDIA_TYPE,                           "media-type" },

    { MIN_VERIFICATION_SCORE,               "min-verification-score" },

    { N_BEST_LIST_LENGTH,                   "n-best-list-length" },

    { NEW_AUDIO_CHANNEL,                    "new-audio-channel" },

    { NEW_PHRASE_ID,                        "new-phrase-id" },

    { NO_INPUT_TIMEOUT,                     "no-input-timeout" },

    { NUM_MAX_VERIFICATION_PHRASES,         "num-max-verification-phrases" },

    { NUM_MIN_CONSISTENT_PRONUNCIATIONS,    "num-min-consistent-pronunciations" },

    { NUM_MIN_VERIFICATION_PHRASES,         "num-min-verification-phrases" },

    { PERSONAL_GRAMMAR_URI,                 "personal-grammar-uri" },

    { PHRASE_ID,                            "phrase-id" },

    { PHRASE_NL,                            "phrase-nl" },

    { PROSODY_CONTOUR,                      "prosody-contour" },

    { PROSODY_DURATION,                     "prosody-duration" },

    { PROSODY_PITCH,                        "prosody-pitch" },

    { PROSODY_RANGE,                        "prosody-range" },

    { PROSODY_RATE,                         "prosody-rate" },

    { PROSODY_VOLUME,                       "prosody-volume" },

    { PROXY_SYNC_ID,                        "proxy-sync-id" },

    { RECOGNITION_MODE,                     "recognition-mode" },

    { RECOGNITION_TIMEOUT,                  "recognition-timeout" },

    { RECOGNIZER_CONTEXT_BLOCK,             "recognizer-context-block" },

    { RECORD_URI,                           "record-uri" },

    { REPOSITORY_URI,                       "repository-uri" },

    { SAVE_BEST_WAVEFORM,                   "save-best-waveform" },

    { SAVE_WAVEFORM,                        "save-waveform" },

    { SENSITIVITY_LEVEL,                    "sensitivity-level" },

    { SET_COOKIE,                           "set-cookie" },

    { SPEAK_LENGTH,                         "speak-length" },

    { SPEAK_RESTART,                        "speak-restart" },

    { SPEAKER_PROFILE,                      "speaker-profile" },

    { SPEECH_COMPLETE_TIMEOUT,              "speech-complete-timeout" },

    { SPEECH_INCOMPLETE_TIMEOUT,            "speech-incomplete-timeout" },

    { SPEECH_LANGUAGE,                      "speech-language" },

    { SPEECH_MARKER,                        "speech-marker" },

    { SPEED_VS_ACCURACY,                    "speed-vs-accuracy" },

    { START_INPUT_TIMERS,                   "start-input-timers" },

    { TRIM_LENGTH,                          "trim-length" },

    { VENDOR_SPECIFIC_PARAMETERS,           "vendor-specific-parameters" },

    { VER_BUFFER_UTTERANCE,                 "ver-buffer-utterance" },

    { VERIFICATION_MODE,                    "verification-mode" },

    { VOICE_AGE,                            "voice-age" },

    { VOICE_GENDER,                         "voice-gender" },

    { VOICE_NAME,                           "voice-name" },

    { VOICE_VARIANT,                        "voice-variant" },

    { VOICEPRINT_EXISTS,                    "voiceprint-exists" },

    { VOICEPRINT_IDENTIFIER,                "voiceprint-identifier" },

    { WAVEFORM_URI,                         "waveform-uri" },

    { WEIGHT,                               "weight" },

    { 0,    NULL }

};

/* Initialize the protocol and registered fields */

static int proto_mrcpv2;

static int hf_mrcpv2_Request_Line;

static int hf_mrcpv2_Response_Line;

static int hf_mrcpv2_Event_Line;

static int hf_mrcpv2_Unknown_Message;

static int hf_mrcpv2_Unknown_Header;

static int hf_mrcpv2_Data;

static int hf_mrcpv2_Method;

static int hf_mrcpv2_Event;

static int hf_mrcpv2_version;

static int hf_mrcpv2_message_length;

static int hf_mrcpv2_request_id;

static int hf_mrcpv2_status_code;

static int hf_mrcpv2_request_state;

static int hf_mrcpv2_Abort_Model;

static int hf_mrcpv2_Abort_Phrase_Enrollment;

static int hf_mrcpv2_Abort_Verification;

static int hf_mrcpv2_Accept;

static int hf_mrcpv2_Accept_Charset;

static int hf_mrcpv2_Active_Request_Id_List;

static int hf_mrcpv2_Adapt_Model;

static int hf_mrcpv2_Audio_Fetch_Hint;

static int hf_mrcpv2_Cache_Control;

static int hf_mrcpv2_Cancel_If_Queue;

static int hf_mrcpv2_Capture_On_Speech;

static int hf_mrcpv2_Channel_Identifier;

static int hf_mrcpv2_Clash_Threshold;

static int hf_mrcpv2_Clear_Dtmf_Buffer;

static int hf_mrcpv2_Completion_Cause;

static int hf_mrcpv2_Completion_Reason;

static int hf_mrcpv2_Confidence_Threshold;

static int hf_mrcpv2_Confusable_Phrases_URI;

static int hf_mrcpv2_Consistency_Threshold;

static int hf_mrcpv2_Content_Base;

static int hf_mrcpv2_Content_Encoding;

static int hf_mrcpv2_Content_ID;

static int hf_mrcpv2_Content_Length;

static int hf_mrcpv2_Content_Location;

static int hf_mrcpv2_Content_Type;

static int hf_mrcpv2_Dtmf_Buffer_Time;

static int hf_mrcpv2_Dtmf_Interdigit_Timeout;

static int hf_mrcpv2_Dtmf_Term_Char;

static int hf_mrcpv2_Dtmf_Term_Timeout;

static int hf_mrcpv2_Early_No_Match;

static int hf_mrcpv2_Enroll_Utterance;

static int hf_mrcpv2_Failed_URI;

static int hf_mrcpv2_Failed_URI_Cause;

static int hf_mrcpv2_Fetch_Hint;

static int hf_mrcpv2_Fetch_Timeout;

static int hf_mrcpv2_Final_Silence;

static int hf_mrcpv2_Hotword_Max_Duration;

static int hf_mrcpv2_Hotword_Min_Duration;

static int hf_mrcpv2_Input_Type;

static int hf_mrcpv2_Input_Waveform_URI;

static int hf_mrcpv2_Interpret_Text;

static int hf_mrcpv2_Jump_Size;

static int hf_mrcpv2_Kill_On_Barge_In;

static int hf_mrcpv2_Lexicon_Search_Order;

static int hf_mrcpv2_Load_Lexicon;

static int hf_mrcpv2_Logging_Tag;

static int hf_mrcpv2_Max_Time;

static int hf_mrcpv2_Media_Type;

static int hf_mrcpv2_Min_Verification_Score;

static int hf_mrcpv2_N_Best_List_Length;

static int hf_mrcpv2_New_Audio_Channel;

static int hf_mrcpv2_New_Phrase_ID;

static int hf_mrcpv2_No_Input_Timeout;

static int hf_mrcpv2_Num_Max_Verification_Phrases;

static int hf_mrcpv2_Num_Min_Consistent_Pronunciations;

static int hf_mrcpv2_Num_Min_Verification_Phrases;

static int hf_mrcpv2_Personal_Grammar_URI;

static int hf_mrcpv2_Phrase_ID;

static int hf_mrcpv2_Phrase_NL;

static int hf_mrcpv2_Prosody_Contour;

static int hf_mrcpv2_Prosody_Duration;

static int hf_mrcpv2_Prosody_Pitch;

static int hf_mrcpv2_Prosody_Range;

static int hf_mrcpv2_Prosody_Rate;

static int hf_mrcpv2_Prosody_Volume;

static int hf_mrcpv2_Proxy_Sync_Id;

static int hf_mrcpv2_Recognition_Mode;

static int hf_mrcpv2_Recognition_Timeout;

static int hf_mrcpv2_Recognizer_Context_Block;

static int hf_mrcpv2_Record_URI;

static int hf_mrcpv2_Repository_URI;

static int hf_mrcpv2_Save_Best_Waveform;

static int hf_mrcpv2_Save_Waveform;

static int hf_mrcpv2_Sensitivity_Level;

static int hf_mrcpv2_Set_Cookie;

static int hf_mrcpv2_Speak_Length;

static int hf_mrcpv2_Speak_Restart;

static int hf_mrcpv2_Speaker_Profile;

static int hf_mrcpv2_Speech_Complete_Timeout;

static int hf_mrcpv2_Speech_Incomplete_Timeout;

static int hf_mrcpv2_Speech_Language;

static int hf_mrcpv2_Speech_Marker;

static int hf_mrcpv2_Speed_Vs_Accuracy;

static int hf_mrcpv2_Start_Input_Timers;

static int hf_mrcpv2_Trim_Length;

static int hf_mrcpv2_Vendor_Specific_Parameters;

static int hf_mrcpv2_Ver_Buffer_Utterance;

static int hf_mrcpv2_Verification_Mode;

static int hf_mrcpv2_Voice_Age;

static int hf_mrcpv2_Voice_Gender;

static int hf_mrcpv2_Voice_Name;

static int hf_mrcpv2_Voice_Variant;

static int hf_mrcpv2_Voiceprint_Exists;

static int hf_mrcpv2_Voiceprint_Identifier;

static int hf_mrcpv2_Waveform_URI;

static int hf_mrcpv2_Weight;

static expert_field ei_mrcpv2_Content_Length_invalid;

/* Global MRCPv2 port pref */

#define TCP_DEFAULT_RANGE "6075, 30000-30200" /* Not IANA registered */

/* Initialize the subtree pointers */

static int ett_mrcpv2;

static int ett_Request_Line;

static int ett_Response_Line;

static int ett_Event_Line;

static int ett_Status_Code;

/* format status code description */

static const string_string status_code_vals[] = {

    { "200", "Success" },

    { "201", "Success with some optional header fields ignored" },

    { "401", "Client Failure: Method not allowed" },

    { "402", "Client Failure: Method not valid in this state" },

    { "403", "Client Failure: Unsupported header field" },

    { "404", "Client Failure: Illegal value for header field. This is the error for a syntax violation." },

    { "405", "Client Failure: Resource not allocated for this session or does not exist" },

    { "406", "Client Failure: Mandatory Header Field Missing" },

    { "407", "Client Failure: Method or Operation Failed (e.g., Grammar compilation failed in the recognizer. Detailed cause codes might be available through a resource specific header.)" },

    { "408", "Client Failure: Unrecognized or unsupported message entity" },

    { "409", "Client Failure: Unsupported Header Field Value. This is a value that is syntactically legal but exceeds the implementation's capabilities or expectations." },

    { "410", "Client Failure: Non-Monotonic or Out of order sequence number in request." },

    { "501", "Server Failure: Server Internal Error" },

    { "502", "Server Failure: Protocol Version not supported" },

    { "503", "Server Failure: Reserved for future assignment" },

    { "504", "Server Failure: Message too large" },

    { NULL, NULL }

};

/* Code to actually dissect the packets */

static int

dissect_mrcpv2_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)

{

    /* Set up structures needed to add the protocol subtree and manage it */

    proto_item *ti;

    proto_tree *mrcpv2_tree;

    unsigned next_offset, linelen;

    unsigned tvb_len;

    uint32_t pdu_size;

    unsigned offset;

    unsigned value_offset;

    unsigned str_len;

    char *header_name;

    char *header_value;

    LINE_TYPE line_type = UNKNOWN_LINE;

    HEADER_TYPE header_type;

    unsigned colon_offset;

    uint32_t content_length;

    proto_item *line_item = NULL;

    proto_item *request_line_item = NULL;

    proto_item *response_line_item = NULL;

    proto_item *event_line_item = NULL;

    proto_item *status_code_item = NULL;

    proto_item *pi = NULL;

    unsigned sp_start;

    unsigned sp_end;

    const char *field1;

    const char *field2;

    const char *field3;

    const char *field4;

    const char *field5 = NULL;

    /* Make entries in Protocol column and Info column on summary display */

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "MRCPv2");

    offset = 0;

    tvb_len = tvb_reported_length(tvb);

    ti = proto_tree_add_item(tree, proto_mrcpv2, tvb, 0, -1, ENC_UTF_8);

    mrcpv2_tree = proto_item_add_subtree(ti, ett_mrcpv2);

    /* get first line */

    tvb_find_line_end_remaining(tvb, offset, &linelen , &next_offset);

    /*  find out MRCP message type:

        request-line    = mrcp-version SP message-length SP method-name SP request-id CRLF

        response-line    = mrcp-version SP message-length SP request-id  SP status-code SP request-state CRLF

        event-line    = mrcp-version SP message-length SP event-name  SP request-id  SP request-state CRLF

    */

    /* version */

    sp_end = tvb_find_uint8_length(tvb, 0, linelen, ' ', &sp_end);

    if ((!tvb_find_uint8_length(tvb, 0, linelen, ' ', &sp_end)) || (sp_end > tvb_len) || (sp_end > linelen)) {

        return -1;

    }

    field1 = (char*)tvb_get_string_enc(pinfo->pool, tvb, 0, sp_end, ENC_ASCII);

    sp_start = sp_end + 1;

    /* length */

    if ((!tvb_find_uint8_length(tvb, sp_start, linelen - sp_start, ' ', &sp_end)) || (sp_end > tvb_len) || (sp_end > linelen))

        return -1;

    field2 = (char*)tvb_get_string_enc(pinfo->pool, tvb, sp_start, sp_end - sp_start, ENC_ASCII);

    sp_start = sp_end + 1;

    /* method, request ID or event */

    if ((!tvb_find_uint8_length(tvb, sp_start, linelen - sp_start, ' ', &sp_end)) || (sp_end > tvb_len) || (sp_end > linelen))

        return -1;

    field3 = (char*)tvb_get_string_enc(pinfo->pool, tvb, sp_start, sp_end - sp_start, ENC_ASCII);

    sp_start = sp_end + 1;

    /* request ID or status code */

    if (!tvb_find_uint8_length(tvb, sp_start, linelen - sp_start, ' ', &sp_end))

    {

        field4 = (char*)tvb_get_string_enc(pinfo->pool, tvb, sp_start, linelen - sp_start, ENC_ASCII);

        line_type = REQUEST_LINE; /* only request line has 4 parameters */

    }

    else

    {

        if ((sp_end > tvb_len) || (sp_end > linelen))

            return -1;

        field4 = (char*)tvb_get_string_enc(pinfo->pool, tvb, sp_start, sp_end - sp_start, ENC_ASCII);

        if (g_ascii_isdigit(field3[0])) /* request ID is number, so it has to be response */

            line_type = RESPONSE_LINE;

        else

            line_type = EVENT_LINE;

        sp_start = sp_end + 1;

        sp_end = linelen;

        if ((sp_end > tvb_len) || (sp_end > linelen))

            return -1;

        field5 = (char*)tvb_get_string_enc(pinfo->pool, tvb, sp_start, sp_end - sp_start, ENC_ASCII);

    }

    /* check pdu size */

    if (!ws_strtou32(field2, NULL, &pdu_size) || pdu_size > (unsigned)tvb_len)

        return -1;

    /* process MRCP header line */

    switch(line_type){

    case REQUEST_LINE:

    {

        col_set_str(pinfo->cinfo, COL_INFO, "Request: ");

        line_item = proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Request_Line, tvb, offset, linelen, ENC_UTF_8);

        request_line_item = proto_item_add_subtree(line_item, ett_Request_Line);

        /* version */

        str_len = (int)strlen(field1);

        proto_tree_add_item(request_line_item, hf_mrcpv2_version, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* message length */

        str_len = (int)strlen(field2);

        proto_tree_add_item(request_line_item, hf_mrcpv2_message_length, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* method name */

        col_append_str(pinfo->cinfo, COL_INFO, field3);

        str_len = (int)strlen(field3);

        proto_tree_add_item(request_line_item, hf_mrcpv2_Method, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* request ID */

        str_len = (int)strlen(field4);

        proto_tree_add_item(request_line_item, hf_mrcpv2_request_id, tvb, offset, str_len, ENC_UTF_8);

        /*offset += str_len + 2;*/ /* add CRLF */

    }

    break;

    case RESPONSE_LINE:

    {

        col_set_str(pinfo->cinfo, COL_INFO, "Response: ");

        line_item = proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Response_Line, tvb, offset, linelen, ENC_UTF_8);

        response_line_item = proto_item_add_subtree(line_item, ett_Response_Line);

        /* version */

        str_len = (int)strlen(field1);

        proto_tree_add_item(response_line_item, hf_mrcpv2_version, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* message length */

        str_len = (int)strlen(field2);

        proto_tree_add_item(response_line_item, hf_mrcpv2_message_length, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* request ID */

        str_len = (int)strlen(field3);

        proto_tree_add_item(response_line_item, hf_mrcpv2_request_id, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* status code */

        str_len = (int)strlen(field4);

        status_code_item = proto_tree_add_item(response_line_item, hf_mrcpv2_status_code, tvb, offset,

            str_len, ENC_UTF_8);

        proto_item_append_text(status_code_item, " %s", str_to_str_wmem(pinfo->pool, field4, status_code_vals, "Unknown Status Code"));

        offset += str_len + 1; /* add SP */

        /* request state */

        col_append_fstr(pinfo->cinfo, COL_INFO, "(%s) %s", field4, field5);

        str_len = (int)strlen(field5);

        proto_tree_add_item(response_line_item, hf_mrcpv2_request_state, tvb, offset, str_len, ENC_UTF_8);

        /*offset += str_len + 2;*/ /* add CRLF */

    }

    break;

    case EVENT_LINE:

    {

        col_set_str(pinfo->cinfo, COL_INFO, "Event: ");

        line_item = proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Event_Line, tvb, offset, linelen, ENC_UTF_8);

        event_line_item = proto_item_add_subtree(line_item, ett_Event_Line);

        /* version */

        str_len = (int)strlen(field1);

        proto_tree_add_item(event_line_item, hf_mrcpv2_version, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* message length */

        str_len = (int)strlen(field2);

        proto_tree_add_item(event_line_item, hf_mrcpv2_message_length, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* event name */

        col_append_str(pinfo->cinfo, COL_INFO, field3);

        str_len = (int)strlen(field3);

        proto_tree_add_item(event_line_item, hf_mrcpv2_Event, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* request ID */

        str_len = (int)strlen(field4);

        proto_tree_add_item(event_line_item, hf_mrcpv2_request_id, tvb, offset, str_len, ENC_UTF_8);

        offset += str_len + 1; /* add SP */

        /* request state */

        str_len = (int)strlen(field5);

        proto_tree_add_item(event_line_item, hf_mrcpv2_request_state, tvb, offset, str_len, ENC_UTF_8);

        /*offset += str_len + 2;*/ /* add CRLF */

    }

    break;

    default:

    {

        /* mark whole packet as unknown and return */

        col_set_str(pinfo->cinfo, COL_INFO, "UNKNOWN message");

        proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Unknown_Message, tvb, offset, tvb_len, ENC_UTF_8);

        return tvb_len;

    }

    }

    if (tree) {

        /* process the rest of the header lines here */

        content_length = 0;

        while (tvb_offset_exists(tvb, next_offset))

        {

            /* get next line */

            offset = next_offset;

            tvb_find_line_end_remaining(tvb, offset, &linelen , &next_offset);

            /* blank line separates msg header and msg body */

            if (linelen == 0)

            {

                if (content_length > 0)

                { /* content length > 0 and CRLF detected, this has to be msg body */

                    offset += 2; /* skip separating CRLF */

                    proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Data, tvb, offset, tvb_len - offset, ENC_ASCII);

                    next_offset = tvb_len; /* we are done */

                }

                continue;

            }

            /* get header type and its value */

            if (!tvb_find_uint8_length(tvb, offset, linelen, ':', &colon_offset))

            { /* header type should end with ':' */

                proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Unknown_Header, tvb, offset, linelen, ENC_UTF_8);

                continue;

            }

            header_name = (char*)tvb_get_string_enc(pinfo->pool, tvb, offset, colon_offset - offset, ENC_ASCII);

            ascii_strdown_inplace(header_name);

            value_offset = tvb_skip_wsp(tvb, colon_offset + 1, offset + linelen - (colon_offset + 1));

            header_value = (char*)tvb_get_string_enc(pinfo->pool, tvb, value_offset, offset + linelen - value_offset, ENC_ASCII);

            /* find out header type */

            header_type = (HEADER_TYPE)str_to_val(header_name, header_type_vals, UNKNOWN);

            /* add header type and value into the tree */

            switch (header_type)

            {

                case ABORT_MODEL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Abort_Model, tvb, offset, linelen, header_value);

                    break;

                case ABORT_PHRASE_ENROLLMENT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Abort_Phrase_Enrollment, tvb, offset, linelen, header_value);

                    break;

                case ABORT_VERIFICATION:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Abort_Verification, tvb, offset, linelen, header_value);

                    break;

                case ACCEPT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Accept, tvb, offset, linelen, header_value);

                    break;

                case ACCEPT_CHARSET:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Accept_Charset, tvb, offset, linelen, header_value);

                    break;

                case ACTIVE_REQUEST_ID_LIST:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Active_Request_Id_List, tvb, offset, linelen, header_value);

                    break;

                case ADAPT_MODEL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Adapt_Model, tvb, offset, linelen, header_value);

                    break;

                case AUDIO_FETCH_HINT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Audio_Fetch_Hint, tvb, offset, linelen, header_value);

                    break;

                case CACHE_CONTROL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Cache_Control, tvb, offset, linelen, header_value);

                    break;

                case CANCEL_IF_QUEUE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Cancel_If_Queue, tvb, offset, linelen, header_value);

                    break;

                case CAPTURE_ON_SPEECH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Capture_On_Speech, tvb, offset, linelen, header_value);

                    break;

                case CHANNEL_IDENTIFIER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Channel_Identifier, tvb, offset, linelen, header_value);

                    break;

                case CLASH_THRESHOLD:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Clash_Threshold, tvb, offset, linelen, header_value);

                    break;

                case CLEAR_DTMF_BUFFER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Clear_Dtmf_Buffer, tvb, offset, linelen, header_value);

                    break;

                case COMPLETION_CAUSE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Completion_Cause, tvb, offset, linelen, header_value);

                    break;

                case COMPLETION_REASON:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Completion_Reason, tvb, offset, linelen, header_value);

                    break;

                case CONFIDENCE_THRESHOLD:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Confidence_Threshold, tvb, offset, linelen, header_value);

                    break;

                case CONFUSABLE_PHRASES_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Confusable_Phrases_URI, tvb, offset, linelen, header_value);

                    break;

                case CONSISTENCY_THRESHOLD:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Consistency_Threshold, tvb, offset, linelen, header_value);

                    break;

                case CONTENT_BASE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_Base, tvb, offset, linelen, header_value);

                    break;

                case CONTENT_ENCODING:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_Encoding, tvb, offset, linelen, header_value);

                    break;

                case CONTENT_ID:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_ID, tvb, offset, linelen, header_value);

                    break;

                case CONTENT_LENGTH:

                    pi = proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_Length, tvb, offset, linelen, header_value);

                    /* if content length is > 0, then there are some data after the headers */

                    if (!ws_strtou32(header_value, NULL, &content_length)) {

                        content_length = 0;

                        expert_add_info(pinfo, pi, &ei_mrcpv2_Content_Length_invalid);

                    }

                    break;

                case CONTENT_LOCATION:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_Location, tvb, offset, linelen, header_value);

                    break;

                case CONTENT_TYPE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Content_Type, tvb, offset, linelen, header_value);

                    break;

                case DTMF_BUFFER_TIME:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Dtmf_Buffer_Time, tvb, offset, linelen, header_value);

                    break;

                case DTMF_INTERDIGIT_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Dtmf_Interdigit_Timeout, tvb, offset, linelen, header_value);

                    break;

                case DTMF_TERM_CHAR:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Dtmf_Term_Char, tvb, offset, linelen, header_value);

                    break;

                case DTMF_TERM_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Dtmf_Term_Timeout, tvb, offset, linelen, header_value);

                    break;

                case EARLY_NO_MATCH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Early_No_Match, tvb, offset, linelen, header_value);

                    break;

                case ENROLL_UTTERANCE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Enroll_Utterance, tvb, offset, linelen, header_value);

                    break;

                case FAILED_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Failed_URI, tvb, offset, linelen, header_value);

                    break;

                case FAILED_URI_CAUSE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Failed_URI_Cause, tvb, offset, linelen, header_value);

                    break;

                case FETCH_HINT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Fetch_Hint, tvb, offset, linelen, header_value);

                    break;

                case FETCH_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Fetch_Timeout, tvb, offset, linelen, header_value);

                    break;

                case FINAL_SILENCE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Final_Silence, tvb, offset, linelen, header_value);

                    break;

                case HOTWORD_MAX_DURATION:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Hotword_Max_Duration, tvb, offset, linelen, header_value);

                    break;

                case HOTWORD_MIN_DURATION:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Hotword_Min_Duration, tvb, offset, linelen, header_value);

                    break;

                case INPUT_TYPE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Input_Type, tvb, offset, linelen, header_value);

                    break;

                case INPUT_WAVEFORM_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Input_Waveform_URI, tvb, offset, linelen, header_value);

                    break;

                case INTERPRET_TEXT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Interpret_Text, tvb, offset, linelen, header_value);

                    break;

                case JUMP_SIZE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Jump_Size, tvb, offset, linelen, header_value);

                    break;

                case KILL_ON_BARGE_IN:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Kill_On_Barge_In, tvb, offset, linelen, header_value);

                    break;

                case LEXICON_SEARCH_ORDER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Lexicon_Search_Order, tvb, offset, linelen, header_value);

                    break;

                case LOAD_LEXICON:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Load_Lexicon, tvb, offset, linelen, header_value);

                    break;

                case LOGGING_TAG:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Logging_Tag, tvb, offset, linelen, header_value);

                    break;

                case MAX_TIME:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Max_Time, tvb, offset, linelen, header_value);

                    break;

                case MEDIA_TYPE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Media_Type, tvb, offset, linelen, header_value);

                    break;

                case MIN_VERIFICATION_SCORE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Min_Verification_Score, tvb, offset, linelen, header_value);

                    break;

                case N_BEST_LIST_LENGTH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_N_Best_List_Length, tvb, offset, linelen, header_value);

                    break;

                case NEW_AUDIO_CHANNEL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_New_Audio_Channel, tvb, offset, linelen, header_value);

                    break;

                case NEW_PHRASE_ID:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_New_Phrase_ID, tvb, offset, linelen, header_value);

                    break;

                case NO_INPUT_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_No_Input_Timeout, tvb, offset, linelen, header_value);

                    break;

                case NUM_MAX_VERIFICATION_PHRASES:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Num_Max_Verification_Phrases, tvb, offset, linelen, header_value);

                    break;

                case NUM_MIN_CONSISTENT_PRONUNCIATIONS:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Num_Min_Consistent_Pronunciations, tvb, offset, linelen, header_value);

                    break;

                case NUM_MIN_VERIFICATION_PHRASES:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Num_Min_Verification_Phrases, tvb, offset, linelen, header_value);

                    break;

                case PERSONAL_GRAMMAR_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Personal_Grammar_URI, tvb, offset, linelen, header_value);

                    break;

                case PHRASE_ID:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Phrase_ID, tvb, offset, linelen, header_value);

                    break;

                case PHRASE_NL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Phrase_NL, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_CONTOUR:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Contour, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_DURATION:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Duration, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_PITCH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Pitch, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_RANGE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Range, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_RATE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Rate, tvb, offset, linelen, header_value);

                    break;

                case PROSODY_VOLUME:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Prosody_Volume, tvb, offset, linelen, header_value);

                    break;

                case PROXY_SYNC_ID:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Proxy_Sync_Id, tvb, offset, linelen, header_value);

                    break;

                case RECOGNITION_MODE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Recognition_Mode, tvb, offset, linelen, header_value);

                    break;

                case RECOGNITION_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Recognition_Timeout, tvb, offset, linelen, header_value);

                    break;

                case RECOGNIZER_CONTEXT_BLOCK:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Recognizer_Context_Block, tvb, offset, linelen, header_value);

                    break;

                case RECORD_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Record_URI, tvb, offset, linelen, header_value);

                    break;

                case REPOSITORY_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Repository_URI, tvb, offset, linelen, header_value);

                    break;

                case SAVE_BEST_WAVEFORM:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Save_Best_Waveform, tvb, offset, linelen, header_value);

                    break;

                case SAVE_WAVEFORM:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Save_Waveform, tvb, offset, linelen, header_value);

                    break;

                case SENSITIVITY_LEVEL:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Sensitivity_Level, tvb, offset, linelen, header_value);

                    break;

                case SET_COOKIE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Set_Cookie, tvb, offset, linelen, header_value);

                    break;

                case SPEAK_LENGTH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speak_Length, tvb, offset, linelen, header_value);

                    break;

                case SPEAK_RESTART:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speak_Restart, tvb, offset, linelen, header_value);

                    break;

                case SPEAKER_PROFILE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speaker_Profile, tvb, offset, linelen, header_value);

                    break;

                case SPEECH_COMPLETE_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speech_Complete_Timeout, tvb, offset, linelen, header_value);

                    break;

                case SPEECH_INCOMPLETE_TIMEOUT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speech_Incomplete_Timeout, tvb, offset, linelen, header_value);

                    break;

                case SPEECH_LANGUAGE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speech_Language, tvb, offset, linelen, header_value);

                    break;

                case SPEECH_MARKER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speech_Marker, tvb, offset, linelen, header_value);

                    break;

                case SPEED_VS_ACCURACY:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Speed_Vs_Accuracy, tvb, offset, linelen, header_value);

                    break;

                case START_INPUT_TIMERS:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Start_Input_Timers, tvb, offset, linelen, header_value);

                    break;

                case TRIM_LENGTH:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Trim_Length, tvb, offset, linelen, header_value);

                    break;

                case VENDOR_SPECIFIC_PARAMETERS:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Vendor_Specific_Parameters, tvb, offset, linelen, header_value);

                    break;

                case VER_BUFFER_UTTERANCE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Ver_Buffer_Utterance, tvb, offset, linelen, header_value);

                    break;

                case VERIFICATION_MODE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Verification_Mode, tvb, offset, linelen, header_value);

                    break;

                case VOICE_AGE:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voice_Age, tvb, offset, linelen, header_value);

                    break;

                case VOICE_GENDER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voice_Gender, tvb, offset, linelen, header_value);

                    break;

                case VOICE_NAME:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voice_Name, tvb, offset, linelen, header_value);

                    break;

                case VOICE_VARIANT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voice_Variant, tvb, offset, linelen, header_value);

                    break;

                case VOICEPRINT_EXISTS:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voiceprint_Exists, tvb, offset, linelen, header_value);

                    break;

                case VOICEPRINT_IDENTIFIER:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Voiceprint_Identifier, tvb, offset, linelen, header_value);

                    break;

                case WAVEFORM_URI:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Waveform_URI, tvb, offset, linelen, header_value);

                    break;

                case WEIGHT:

                    proto_tree_add_string(mrcpv2_tree, hf_mrcpv2_Weight, tvb, offset, linelen, header_value);

                    break;

                default:

                    proto_tree_add_item(mrcpv2_tree, hf_mrcpv2_Unknown_Header, tvb, offset, linelen, ENC_UTF_8);

                    break;

            }

        }

    }

    /* Return the amount of data this dissector was able to dissect */

    return tvb_captured_length(tvb);

}

/* get the length of the MRCP message */

static unsigned

get_mrcpv2_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)

{

    unsigned len_start;

    unsigned len_end;

    const char *msg_len;

    uint32_t num_msg_len = 0;

    /* first string is version */

    if (!tvb_find_uint8_length(tvb, offset, MRCPV2_MIN_PDU_LEN, ' ', &len_start))

        return 0;

    len_start += 1; /* skip whitespace */

    /* second string is message length */

    if (!tvb_find_uint8_length(tvb, len_start, MRCPV2_MIN_PDU_LEN - len_start, ' ', &len_end))

        msg_len = (char*)tvb_get_string_enc(pinfo->pool, tvb, len_start, MRCPV2_MIN_PDU_LEN - len_start, ENC_ASCII);

    else

        msg_len = (char*)tvb_get_string_enc(pinfo->pool, tvb, len_start, len_end - len_start, ENC_ASCII);