void ks_parse_http_session_request_line(ks_http_session_t *session,packet_info *pinfo,tvbuff_t *tvb, int offset,const guchar *line, const guchar *lineend){
const gchar *token;
const guchar *next_token;
int tokenlen;
ks_http_session_request_t *r;
if(session->request == NULL){
init_http_session_request(session);
}
r = session->request;
if(r == NULL||line==NULL){
return;
}
session->state = HTTP_SESSION_REQUEST_STATE;
set_http_session_ids(session->pool,&r->ids,pinfo);
r->request_line = mp_pstrndup(session->pool,line,(size_t)(lineend-line));
/* The first token is the method. */
tokenlen = get_token_len(line, lineend, &next_token);
if (tokenlen == 0)
return;
token = tvb_get_ephemeral_string(tvb, offset, tokenlen);
r->method = mp_pstrdup(session->pool,token);
if ((next_token - line) > 2 && next_token[-1] == ' ' && next_token[-2] == ' ') {
/* Two spaces in a now indicates empty URI, so roll back one here */
next_token--;
}
offset += (int) (next_token - line);
line = next_token;
/* The next token is the URI. */
tokenlen = get_token_len(line, lineend, &next_token);
token = tvb_get_ephemeral_string_enc(tvb, offset, tokenlen,ENC_UTF_8);
r->uri = mp_pstrdup(session->pool,token);
r->args = get_http_session_query_str(r->uri);
offset += (int) (next_token - line);
line = next_token;
/* Everything to the end of the line is the version. */
tokenlen = (int) (lineend - line);
token = tvb_get_ephemeral_string(tvb, offset, tokenlen);
r->http_protocol = mp_pstrdup(session->pool,token);
}
static int SdpConnectionInfo(const char *data, int len, sdp_msg *msg)
{
const char *next_token;
const char *lineend;
int tokenlen;
lineend = data + len;
/* The first token is connection type */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || data[tokenlen] != ' ') {
return -1;
}
if (strncmp(data, "IN", tokenlen) == 0) {
msg->cntn_info.nettype = SDP_NETTP_IN;
}
else {
return -1;
}
data = next_token;
/* next token is address type */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || data[tokenlen] != ' ') {
msg->cntn_info.nettype = SDP_NETTP_NONE;
return -1;
}
if (strncmp(data, "IP4", tokenlen) == 0) {
msg->cntn_info.nettype = SDP_ADDRTP_IP4;
}
else if (strncmp(data, "IP6", tokenlen) == 0) {
msg->cntn_info.nettype = SDP_ADDRTP_IP6;
}
else {
msg->cntn_info.nettype = SDP_NETTP_NONE;
return -1;
}
data = next_token;
/* next token is address */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || (data[tokenlen] != '\r' && data[tokenlen] != '\n')) {
msg->cntn_info.nettype = SDP_NETTP_NONE;
msg->cntn_info.nettype = SDP_ADDRTP_NONE;
return -1;
}
msg->cntn_info.address = DMemMalloc(tokenlen + 1);
memcpy(msg->cntn_info.address, data, tokenlen);
msg->cntn_info.address[tokenlen] = '\0';
return 0;
}
void ks_parse_http_session_response_line(ks_http_session_t *session,packet_info *pinfo,tvbuff_t *tvb, int offset, const guchar *line, const guchar *lineend){
const guchar *next_token;
int tokenlen;
gchar response_code_chars[4];
ks_http_session_response_t *r;
if(session->response == NULL){
init_http_session_response(session);
}
r = session->response;
if(r == NULL||line == NULL){
return;
}
session->state = HTTP_SESSION_RESPONSE_STATE;
set_http_session_ids(session->pool,&r->ids,pinfo);
r->status_line = mp_pstrndup(session->pool,line,(size_t)(lineend-line));
/*
* The first token is the HTTP Version.
*/
tokenlen = get_token_len(line, lineend, &next_token);
if (tokenlen == 0)
return;
/* Advance to the start of the next token. */
offset += (int) (next_token - line);
line = next_token;
/*
* The second token is the Status Code.
*/
tokenlen = get_token_len(line, lineend, &next_token);
if (tokenlen < 3)
return;
/* The Status Code characters must be copied into a null-terminated
* buffer for strtoul() to parse them into an unsigned integer value.
*/
memcpy(response_code_chars, line, 3);
response_code_chars[3] = '\0';
r->status = (guint)strtoul(response_code_chars, NULL, 10);
}
static const char * get_next_token(const char * s) {
uint8_t i;
i = get_token_len(s);
if (s[i] == '#')
return s+i+1;
return NULL;
}
int cmdline_complete_get_elt_string(cmdline_parse_token_hdr_t *tk, int idx,
char *dstbuf, unsigned int size)
{
struct cmdline_token_string *tk2;
struct cmdline_token_string_data *sd;
const char *s;
unsigned int len;
if (!tk || !dstbuf || idx < 0)
return -1;
tk2 = (struct cmdline_token_string *)tk;
sd = &tk2->string_data;
s = sd->str;
while (idx-- && s)
s = get_next_token(s);
if (!s)
return -1;
len = get_token_len(s);
if (len > size - 1)
return -1;
memcpy(dstbuf, s, len);
dstbuf[len] = '\0';
return 0;
}
int8_t parse_string(parse_token_hdr_t * tk, const char * buf, void * res) {
struct token_string_data sd;
uint8_t token_len;
const char * str;
if(*buf==0)
return -1;
memcpy(&sd, &((struct token_string *)tk)->string_data, sizeof(sd));
/* fixed string */
if (sd.str) {
str = sd.str;
do {
token_len = get_token_len(str);
/* if token is too big... */
if(token_len >= STR_TOKEN_SIZE - 1)
continue;
if(strncmp(buf, str, token_len))
continue;
if(!isendoftoken(*(buf+token_len)))
continue;
break;
} while ((str = get_next_token(str))!= NULL );
if (!str)
return -1;
}
/* unspecified string */
else {
token_len=0;
while(!isendoftoken(buf[token_len]) && token_len < (STR_TOKEN_SIZE-1))
token_len++;
/* return if token too long */
if(token_len >= STR_TOKEN_SIZE - 1)
return -1;
}
if(res) {
/* we are sure that token_len is < STR_TOKEN_SIZE-1 */
strncpy(res, buf, token_len);
*((char *)res + token_len) = 0;
}
return token_len;
}
static bool is_keyword( char* cur )
{
size_t len = get_token_len( cur );
// put a terminating zero after the given token
char tmp = *(cur + len);
*(cur+len) = '\0';
KeywordMapT::iterator i;
i = __gMultiLangMap.find( cur );
// restore original character suppresed by terminating zero
*(cur + len) = tmp;
return i == __gMultiLangMap.end() ? false : true;
}
static inline bool cmp_tokens( char* tok1, char* tok2 )
{
// NOTE:: the case one token includes
// other in it's entirely is not handled
size_t len = get_token_len( tok1 );
// assuming that tokens are non-zero length
do
{
if ( *(tok1++) != *(tok2++) )
return false;
--len;
} while ( --len );
return true;
}
bool parseSelectReply(redisClient *c,
bool is_scan,
bool *no_wc,
int *tmatch,
int cmatchs[MAX_COLUMN_PER_TABLE],
int *qcols,
bool *join,
bool *cstar,
char *clist,
char *from,
char *tlist,
char *where) {
if (strcasecmp(from, "FROM")) {
addReply(c, shared.selectsyntax_nofrom);
return 0;
}
if (!where || strcasecmp(where, "WHERE")) {
if (is_scan) {
*no_wc = 1;
} else {
addReply(c, shared.selectsyntax_nowhere);
return 0;
}
}
if (strchr(tlist, ',')) {
*join = 1;
return 1;
}
*join = 0;
*tmatch = find_table_n(tlist, get_token_len(tlist));
if (*tmatch == -1) {
addReply(c, shared.nonexistenttable);
return 0;
}
return parseCommaSpaceListReply(c, clist, 1, 0, 0, *tmatch, cmatchs,
0, NULL, NULL, NULL, qcols, cstar);
}
int8_t complete_get_elt_string(parse_token_hdr_t * tk, int8_t idx, char * dstbuf, uint8_t size) {
struct token_string_data sd;
const char * s;
uint8_t len;
memcpy(&sd, &((struct token_string *)tk)->string_data, sizeof(sd));
s = sd.str;
while (idx-- && s)
s = get_next_token(s);
if (s==NULL)
return -1;
len = get_token_len(s);
if (len > size - 1)
return -1;
memcpy(dstbuf, s, len);
dstbuf[len] = '\0';
return 0;
}
bool CJSourceParser::CheckVisibilty( char*& cur )
{
size_t len = get_token_len( cur );
if ( cmp_tokens_fast( cur, "public:", len ) )
{
mCurVis = SP_VIS_PUBLIC;
return true;
}
if ( cmp_tokens_fast( cur, "protected:", len ) )
{
mCurVis = SP_VIS_PROTECTED;
return true;
}
if ( cmp_tokens_fast( cur, "private:", len ) )
{
mCurVis = SP_VIS_PRIVATE;
return true;
}
return false;
}
static void
dissect_pop(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
struct pop_proto_data *frame_data_p;
gboolean is_request;
gboolean is_continuation;
proto_tree *pop_tree, *reqresp_tree;
proto_item *ti;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
int tokenlen;
const guchar *next_token;
fragment_data *frag_msg = NULL;
tvbuff_t *next_tvb = NULL;
conversation_t *conversation = NULL;
struct pop_data_val *data_val = NULL;
gint length_remaining;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "POP");
/*
* Find the end of the first line.
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
if (pinfo->match_port == pinfo->destport) {
is_request = TRUE;
is_continuation = FALSE;
} else {
is_request = FALSE;
is_continuation = response_is_continuation(line);
}
frame_data_p = p_get_proto_data(pinfo->fd, proto_pop);
if (!frame_data_p) {
conversation = find_conversation(pinfo->fd->num,
&pinfo->src, &pinfo->dst,
pinfo->ptype,
pinfo->srcport, pinfo->destport, 0);
if (conversation == NULL) { /* No conversation, create one */
conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->srcport,
pinfo->destport, 0);
}
data_val = conversation_get_proto_data(conversation, proto_pop);
if (!data_val) {
/*
* No - create one and attach it.
*/
data_val = se_alloc0(sizeof(struct pop_data_val));
conversation_add_proto_data(conversation, proto_pop, data_val);
}
}
if (check_col(pinfo->cinfo, COL_INFO)) {
/*
* Put the first line from the buffer into the summary
* if it's a POP request or reply (but leave out the
* line terminator).
* Otherwise, just call it a continuation.
*/
if (is_continuation) {
length_remaining = tvb_length_remaining(tvb, offset);
col_add_fstr(pinfo->cinfo, COL_INFO, "S: DATA fragment, %d byte%s",
length_remaining, plurality (length_remaining, "", "s"));
}
else
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s", is_request ? "C" : "S",
format_text(line, linelen));
}
ti = proto_tree_add_item(tree, proto_pop, tvb, offset, -1, FALSE);
pop_tree = proto_item_add_subtree(ti, ett_pop);
if (is_continuation) {
if (pop_data_desegment) {
if (!frame_data_p) {
data_val->msg_read_len += tvb_length(tvb);
frame_data_p = se_alloc(sizeof(struct pop_proto_data));
frame_data_p->conversation_id = conversation->index;
frame_data_p->more_frags = data_val->msg_read_len < data_val->msg_tot_len;
p_add_proto_data(pinfo->fd, proto_pop, frame_data_p);
}
frag_msg = fragment_add_seq_next(tvb, 0, pinfo,
frame_data_p->conversation_id,
pop_data_segment_table,
pop_data_reassembled_table,
tvb_length(tvb),
frame_data_p->more_frags);
next_tvb = process_reassembled_data(tvb, offset, pinfo,
"Reassembled DATA",
frag_msg, &pop_data_frag_items,
NULL, pop_tree);
if (next_tvb) {
if (imf_handle)
call_dissector(imf_handle, next_tvb, pinfo, tree);
if (data_val) {
/* we have read everything - reset */
data_val->msg_read_len = 0;
data_val->msg_tot_len = 0;
}
pinfo->fragmented = FALSE;
} else {
pinfo->fragmented = TRUE;
}
} else {
/*
* Put the whole packet into the tree as data.
*/
call_dissector(data_handle,tvb, pinfo, pop_tree);
}
return;
}
/*
* Put the line into the protocol tree.
*/
ti = proto_tree_add_string_format(pop_tree,
(is_request) ?
hf_pop_request :
hf_pop_response,
tvb, offset,
next_offset - offset,
"", "%s",
tvb_format_text(tvb, offset, next_offset - offset));
reqresp_tree = proto_item_add_subtree(ti, ett_pop_reqresp);
/*
* Extract the first token, and, if there is a first
* token, add it as the request or reply code.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
proto_tree_add_item(reqresp_tree,
(is_request) ?
hf_pop_request_command :
hf_pop_response_indicator,
tvb, offset, tokenlen, FALSE);
if (data_val) {
if (is_request) {
/* see if this is RETR or TOP command */
if (g_ascii_strncasecmp(line, "RETR", 4) == 0 ||
g_ascii_strncasecmp(line, "TOP", 3) == 0)
/* the next response will tell us how many bytes */
data_val->msg_request = TRUE;
} else {
if (data_val->msg_request) {
/* this is a response to a RETR or TOP command */
if (g_ascii_strncasecmp(line, "+OK ", 4) == 0) {
/* the message will be sent - work out how many bytes */
data_val->msg_read_len = 0;
data_val->msg_tot_len = atoi(line + 4);
}
data_val->msg_request = FALSE;
}
}
}
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
}
if (tree) {
/*
* Add the rest of the first line as request or
* reply param/description.
*/
if (linelen != 0) {
proto_tree_add_item(reqresp_tree,
(is_request) ?
hf_pop_request_parameter :
hf_pop_response_description,
tvb, offset, linelen, FALSE);
}
offset = next_offset;
/*
* Show the rest of the request or response as text,
* a line at a time.
*/
while (tvb_offset_exists(tvb, offset)) {
/*
* Find the end of the line.
*/
tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
/*
* Put this line.
*/
proto_tree_add_string_format(pop_tree,
(is_request) ?
hf_pop_request_data :
hf_pop_response_data,
tvb, offset,
next_offset - offset,
"", "%s",
tvb_format_text(tvb, offset, next_offset - offset));
offset = next_offset;
}
}
}
static void
dissect_gift(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
proto_item *ti, *hidden_item;
proto_tree *gift_tree, *cmd_tree;
gboolean is_request;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
int tokenlen;
const guchar *next_token;
/* set "Protocol" column text */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "giFT");
/* determine whether it is a request to or response from the server */
if (pinfo->match_uint == pinfo->destport)
is_request = TRUE;
else
is_request = FALSE;
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
/* set "Info" column text */
if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
/* if tree != NULL, build protocol tree */
if (tree) {
ti = proto_tree_add_item(tree, proto_gift, tvb, 0, -1, ENC_NA);
gift_tree = proto_item_add_subtree(ti, ett_gift);
if (is_request) {
hidden_item = proto_tree_add_boolean(gift_tree, hf_gift_request, tvb, 0, 0, TRUE);
} else {
hidden_item = proto_tree_add_boolean(gift_tree, hf_gift_response, tvb, 0, 0, TRUE);
}
PROTO_ITEM_SET_HIDDEN(hidden_item);
ti = proto_tree_add_text(gift_tree, tvb, offset, next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
cmd_tree = proto_item_add_subtree(ti, ett_gift_cmd);
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
if (is_request) {
proto_tree_add_text(cmd_tree, tvb, offset,
tokenlen, "Request Command: %s",
format_text(line, tokenlen));
} else {
proto_tree_add_text(cmd_tree, tvb, offset,
tokenlen, "Response Command: %s",
format_text(line, tokenlen));
}
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
}
if (linelen != 0) {
if (is_request) {
proto_tree_add_text(cmd_tree, tvb, offset,
linelen, "Request Arg: %s",
format_text(line, linelen));
} else {
proto_tree_add_text(cmd_tree, tvb, offset,
linelen, "Response Arg: %s",
format_text(line, linelen));
}
}
}
}
static void
dissect_imap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
gboolean is_request;
proto_tree *imap_tree, *reqresp_tree;
proto_item *ti, *hidden_item;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
int tokenlen;
const guchar *next_token;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IMAP");
if (pinfo->match_uint == pinfo->destport)
is_request = TRUE;
else
is_request = FALSE;
if (check_col(pinfo->cinfo, COL_INFO)) {
/*
* Put the first line from the buffer into the summary
* (but leave out the line terminator).
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_imap, tvb, offset, -1, ENC_NA);
imap_tree = proto_item_add_subtree(ti, ett_imap);
hidden_item = proto_tree_add_boolean(imap_tree, hf_imap_isrequest, tvb, 0, 0, is_request);
PROTO_ITEM_SET_HIDDEN(hidden_item);
while(tvb_length_remaining(tvb, offset) > 2) {
/*
* Find the end of each line
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
/*
* Put the line into the protocol tree.
*/
ti = proto_tree_add_item(imap_tree, hf_imap_line, tvb, offset,
next_offset - offset, ENC_ASCII|ENC_NA);
reqresp_tree = proto_item_add_subtree(ti, ett_imap_reqresp);
/*
* Show each line as tags + requests or replies.
*/
/*
* Extract the first token, and, if there is a first
* token, add it as the request or reply tag.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
proto_tree_add_item(reqresp_tree, (is_request) ? hf_imap_request_tag : hf_imap_response_tag,
tvb, offset, tokenlen, ENC_ASCII|ENC_NA);
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
}
/*
* Add the rest of the line as request or reply data.
*/
if (linelen != 0) {
proto_tree_add_item(reqresp_tree, (is_request) ? hf_imap_request : hf_imap_response,
tvb, offset, linelen, ENC_ASCII|ENC_NA);
}
offset += linelen+2; /* Skip over last line and \r\n at the end of it */
}
}
}
static void
dissect_ftp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
gboolean is_request;
proto_tree *ftp_tree = NULL;
proto_tree *reqresp_tree = NULL;
proto_item *ti, *hidden_item;
gint offset = 0;
const guchar *line;
guint32 code;
gchar code_str[4];
gboolean is_port_request = FALSE;
gboolean is_pasv_response = FALSE;
gboolean is_epasv_response = FALSE;
gint next_offset;
int linelen;
int tokenlen;
const guchar *next_token;
guint32 pasv_ip;
guint32 ftp_ip;
guint16 ftp_port;
address ftp_ip_address;
gboolean ftp_nat;
conversation_t *conversation;
ftp_ip_address = pinfo->src;
if (pinfo->match_uint == pinfo->destport)
is_request = TRUE;
else
is_request = FALSE;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FTP");
/*
* Find the end of the first line.
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
/*
* Put the first line from the buffer into the summary
* (but leave out the line terminator).
*/
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
if (tree) {
ti = proto_tree_add_item(tree, proto_ftp, tvb, offset, -1, ENC_NA);
ftp_tree = proto_item_add_subtree(ti, ett_ftp);
if (is_request) {
hidden_item = proto_tree_add_boolean(ftp_tree,
hf_ftp_request, tvb, 0, 0, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
hidden_item = proto_tree_add_boolean(ftp_tree,
hf_ftp_response, tvb, 0, 0, FALSE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
} else {
hidden_item = proto_tree_add_boolean(ftp_tree,
hf_ftp_request, tvb, 0, 0, FALSE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
hidden_item = proto_tree_add_boolean(ftp_tree,
hf_ftp_response, tvb, 0, 0, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
}
/*
* Put the line into the protocol tree.
*/
ti = proto_tree_add_text(ftp_tree, tvb, offset,
next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
reqresp_tree = proto_item_add_subtree(ti, ett_ftp_reqresp);
}
if (is_request) {
/*
* Extract the first token, and, if there is a first
* token, add it as the request.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
if (tree) {
proto_tree_add_item(reqresp_tree,
hf_ftp_request_command, tvb, offset,
tokenlen, ENC_ASCII|ENC_NA);
}
if (strncmp(line, "PORT", tokenlen) == 0)
is_port_request = TRUE;
}
} else {
/*
* This is a response; the response code is 3 digits,
* followed by a space or hyphen, possibly followed by
* text.
*
* If the line doesn't start with 3 digits, it's part of
* a continuation.
*
* XXX - keep track of state in the first pass, and
* treat non-continuation lines not beginning with digits
* as errors?
*/
if (linelen >= 3 && isdigit(line[0]) && isdigit(line[1])
&& isdigit(line[2])) {
/*
* One-line reply, or first or last line
* of a multi-line reply.
*/
tvb_get_nstringz0(tvb, offset, sizeof(code_str), code_str);
code = strtoul(code_str, NULL, 10);
if (tree) {
proto_tree_add_uint(reqresp_tree,
hf_ftp_response_code, tvb, offset, 3, code);
}
/*
* See if it's a passive-mode response.
*
* XXX - does anybody do FOOBAR, as per RFC
* 1639, or has that been supplanted by RFC 2428?
*/
if (code == 227)
is_pasv_response = TRUE;
/*
* Responses to EPSV command, as per RFC 2428
* XXX - handle IPv6?
*/
if (code == 229)
is_epasv_response = TRUE;
/*
* Skip the 3 digits and, if present, the
* space or hyphen.
*/
if (linelen >= 4)
next_token = line + 4;
else
next_token = line + linelen;
} else {
/*
* Line doesn't start with 3 digits; assume it's
* a line in the middle of a multi-line reply.
*/
next_token = line;
}
}
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
if (tree) {
/*
* Add the rest of the first line as request or
* reply data.
*/
if (linelen != 0) {
if (is_request) {
proto_tree_add_item(reqresp_tree,
hf_ftp_request_arg, tvb, offset,
linelen, ENC_ASCII|ENC_NA);
} else {
proto_tree_add_item(reqresp_tree,
hf_ftp_response_arg, tvb, offset,
linelen, ENC_ASCII|ENC_NA);
}
}
offset = next_offset;
}
/*
* If this is a PORT request or a PASV response, handle it.
*/
if (is_port_request) {
if (parse_port_pasv(line, linelen, &ftp_ip, &ftp_port)) {
if (tree) {
proto_tree_add_ipv4(reqresp_tree,
hf_ftp_active_ip, tvb, 0, 0,
ftp_ip);
proto_tree_add_uint(reqresp_tree,
hf_ftp_active_port, tvb, 0, 0,
ftp_port);
}
SET_ADDRESS(&ftp_ip_address, AT_IPv4, 4, (const guint8 *)&ftp_ip);
ftp_nat = !ADDRESSES_EQUAL(&pinfo->src, &ftp_ip_address);
if (ftp_nat) {
if (tree) {
proto_tree_add_boolean(
reqresp_tree,
hf_ftp_active_nat, tvb,
0, 0, ftp_nat);
}
}
}
}
if (is_pasv_response) {
if (linelen != 0) {
/*
* This frame contains a PASV response; set up a
* conversation for the data.
*/
if (parse_port_pasv(line, linelen, &pasv_ip, &ftp_port)) {
if (tree) {
proto_tree_add_ipv4(reqresp_tree,
hf_ftp_pasv_ip, tvb, 0, 0, pasv_ip);
proto_tree_add_uint(reqresp_tree,
hf_ftp_pasv_port, tvb, 0, 0,
ftp_port);
}
SET_ADDRESS(&ftp_ip_address, AT_IPv4, 4,
(const guint8 *)&pasv_ip);
ftp_nat = !ADDRESSES_EQUAL(&pinfo->src, &ftp_ip_address);
if (ftp_nat) {
if (tree) {
proto_tree_add_boolean(reqresp_tree,
hf_ftp_pasv_nat, tvb, 0, 0,
ftp_nat);
}
}
/*
* We use "ftp_ip_address", so that if
* we're NAT'd we look for the un-NAT'd
* connection.
*
* XXX - should this call to
* "find_conversation()" just use
* "ftp_ip_address" and "server_port", and
* wildcard everything else?
*/
conversation = find_conversation(pinfo->fd->num, &ftp_ip_address,
&pinfo->dst, PT_TCP, ftp_port, 0,
NO_PORT_B);
if (conversation == NULL) {
/*
* XXX - should this call to "conversation_new()"
* just use "ftp_ip_address" and "server_port",
* and wildcard everything else?
*
* XXX - what if we did find a conversation? As
* we create it only on the first pass through the
* packets, if we find one, it's presumably an
* unrelated conversation. Should we remove the
* old one from the hash table and put this one in
* its place? Can the conversation code handle
* conversations not in the hash table? Or should
* we make conversations support start and end
* frames, as circuits do, and treat this as an
* indication that one conversation was closed and
* a new one was opened?
*/
conversation = conversation_new(
pinfo->fd->num, &ftp_ip_address, &pinfo->dst,
PT_TCP, ftp_port, 0, NO_PORT2);
conversation_set_dissector(conversation, ftpdata_handle);
}
}
}
}
if (is_epasv_response) {
if (linelen != 0) {
/*
* This frame contains an EPSV response; set up a
* conversation for the data.
*/
if (parse_extended_pasv_response(line, linelen, &ftp_port)) {
/* Add port number to tree */
if (tree) {
proto_tree_add_uint(reqresp_tree,
hf_ftp_pasv_port, tvb, 0, 0,
ftp_port);
}
/* Find/create conversation for data */
conversation = find_conversation(pinfo->fd->num, &pinfo->src,
&pinfo->dst, PT_TCP, ftp_port, 0,
NO_PORT_B);
if (conversation == NULL) {
conversation = conversation_new(
pinfo->fd->num, &pinfo->src, &pinfo->dst,
PT_TCP, ftp_port, 0, NO_PORT2);
conversation_set_dissector(conversation,
ftpdata_handle);
}
}
}
}
if (tree) {
/*
* Show the rest of the request or response as text,
* a line at a time.
* XXX - only if there's a continuation indicator?
*/
while (tvb_offset_exists(tvb, offset)) {
/*
* Find the end of the line.
*/
tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
/*
* Put this line.
*/
proto_tree_add_text(ftp_tree, tvb, offset,
next_offset - offset, "%s",
tvb_format_text(tvb, offset, next_offset - offset));
offset = next_offset;
}
}
}
static void
dissect_imap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
gboolean is_request;
proto_tree *imap_tree, *reqresp_tree;
proto_item *ti, *hidden_item;
gint offset = 0;
gint uid_offset = 0;
gint folder_offset = 0;
const guchar *line;
const guchar *uid_line;
const guchar *folder_line;
gint next_offset;
int linelen;
int tokenlen;
int uid_tokenlen;
int folder_tokenlen;
const guchar *next_token;
const guchar *uid_next_token;
const guchar *folder_next_token;
guchar *tokenbuf;
guchar *command_token;
int iter;
int commandlen;
conversation_t *conversation;
imap_state_t *session_state;
conversation = find_or_create_conversation(pinfo);
session_state = (imap_state_t *)conversation_get_proto_data(conversation, proto_imap);
if (!session_state) {
session_state = wmem_new0(wmem_file_scope(), imap_state_t);
session_state->ssl_requested = FALSE;
conversation_add_proto_data(conversation, proto_imap, session_state);
}
tokenbuf = (guchar *)wmem_alloc0(wmem_packet_scope(), MAX_BUFFER);
command_token = (guchar *)wmem_alloc0(wmem_packet_scope(), MAX_BUFFER);
commandlen = 0;
folder_offset = 0;
folder_tokenlen = 0;
folder_line = NULL;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "IMAP");
if (pinfo->match_uint == pinfo->destport)
is_request = TRUE;
else
is_request = FALSE;
/*
* Put the first line from the buffer into the summary
* (but leave out the line terminator).
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s", is_request ? "Request" : "Response", format_text(line, linelen));
{
ti = proto_tree_add_item(tree, proto_imap, tvb, offset, -1, ENC_NA);
imap_tree = proto_item_add_subtree(ti, ett_imap);
hidden_item = proto_tree_add_boolean(imap_tree, hf_imap_isrequest, tvb, 0, 0, is_request);
PROTO_ITEM_SET_HIDDEN(hidden_item);
while(tvb_offset_exists(tvb, offset)) {
/*
* Find the end of each line
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
/*
* Put the line into the protocol tree.
*/
ti = proto_tree_add_item(imap_tree, hf_imap_line, tvb, offset, next_offset - offset, ENC_ASCII|ENC_NA);
reqresp_tree = proto_item_add_subtree(ti, ett_imap_reqresp);
/*
* Check that the line doesn't begin with '*', because that's a continuation line.
* Otherwise if a tag is present then extract tokens.
*/
if ( (line) && ((line[0] != '*') || (TRUE == is_request)) ) {
/*
* Show each line as tags + requests or replies.
*/
/*
* Extract the first token, and, if there is a first
* token, add it as the request or reply tag.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
proto_tree_add_item(reqresp_tree, (is_request) ? hf_imap_request_tag : hf_imap_response_tag, tvb, offset, tokenlen, ENC_ASCII|ENC_NA);
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
}
/*
* Extract second token, and, if there is a second
* token, and it's not uid, add it as the request or reply command.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
for (iter = 0; iter < tokenlen && iter < MAX_BUFFER-1; iter++) {
tokenbuf[iter] = g_ascii_tolower(line[iter]);
}
if (tree && is_request && strncmp(tokenbuf, "uid", tokenlen) == 0) {
proto_tree_add_item(reqresp_tree, hf_imap_request_uid, tvb, offset, tokenlen, ENC_ASCII|ENC_NA);
/*
* UID is a precursor to a command, if following the tag,
* so move to next token to grab the actual command.
*/
uid_offset = offset;
uid_offset += (gint) (next_token - line);
uid_line = next_token;
uid_tokenlen = get_token_len(uid_line, uid_line + (linelen - tokenlen), &uid_next_token);
if (tokenlen != 0) {
proto_tree_add_item(reqresp_tree, hf_imap_request_command, tvb, uid_offset, uid_tokenlen, ENC_ASCII|ENC_NA);
/*
* Save command string to do specialized processing.
*/
for (iter = 0; iter < uid_tokenlen && iter < MAX_BUFFER-1; iter++) {
command_token[iter] = g_ascii_tolower(uid_line[iter]);
}
commandlen = uid_tokenlen;
folder_offset = uid_offset;
folder_offset += (gint) (uid_next_token - uid_line);
folder_line = uid_next_token;
folder_tokenlen = get_token_len(folder_line, folder_line + (linelen - tokenlen - uid_tokenlen), &folder_next_token);
}
} else {
/*
* Not a UID request so perform normal parsing.
*/
proto_tree_add_item(reqresp_tree, (is_request) ? hf_imap_request_command : hf_imap_response_status, tvb, offset, tokenlen, ENC_ASCII|ENC_NA);
if (is_request) {
/*
* Save command string to do specialized processing.
*/
for (iter = 0; iter < tokenlen && iter < 256; iter++) {
command_token[iter] = g_ascii_tolower(line[iter]);
}
commandlen = tokenlen;
folder_offset = offset;
folder_offset += (gint) (next_token - line);
folder_line = next_token;
folder_tokenlen = get_token_len(folder_line, folder_line + (linelen - tokenlen - 1), &folder_next_token);
}
}
if (tree && commandlen > 0 && (
strncmp(command_token, "select", commandlen) == 0 ||
strncmp(command_token, "examine", commandlen) == 0 ||
strncmp(command_token, "create", commandlen) == 0 ||
strncmp(command_token, "delete", commandlen) == 0 ||
strncmp(command_token, "rename", commandlen) == 0 ||
strncmp(command_token, "subscribe", commandlen) == 0 ||
strncmp(command_token, "unsubscribe", commandlen) == 0 ||
strncmp(command_token, "status", commandlen) == 0 ||
strncmp(command_token, "append", commandlen) == 0 ||
strncmp(command_token, "search", commandlen) == 0)) {
/*
* These commands support folder as an argument,
* so parse out the folder name.
*/
if (folder_tokenlen != 0)
proto_tree_add_item(reqresp_tree, hf_imap_request_folder, tvb, folder_offset, folder_tokenlen, ENC_ASCII|ENC_NA);
}
if (tree && is_request && (NULL != folder_line) && strncmp(command_token, "copy", commandlen) == 0) {
/*
* Handle the copy command separately since folder
* is the second argument for this command.
*/
folder_offset += (gint) (folder_next_token - folder_line);
folder_line = folder_next_token;
folder_tokenlen = get_token_len(folder_line, folder_line + (linelen - tokenlen), &folder_next_token);
if (folder_tokenlen != 0)
proto_tree_add_item(reqresp_tree, hf_imap_request_folder, tvb, folder_offset, folder_tokenlen, ENC_ASCII|ENC_NA);
}
/* If not yet switched to TLS, check for STARTTLS. */
if (session_state->ssl_requested) {
if (!is_request && session_state->ssl_requested &&
strncmp(tokenbuf, "ok", tokenlen) == 0) {
/* STARTTLS accepted, next reply will be TLS. */
ssl_starttls_ack(ssl_handle, pinfo, imap_handle);
}
session_state->ssl_requested = FALSE;
}
if (is_request && commandlen > 0 &&
strncmp(command_token, "starttls", commandlen) == 0) {
/* If next response is OK, then TLS should be commenced. */
session_state->ssl_requested = TRUE;
}
}
/*
* Add the rest of the line as request or reply data.
*/
if (linelen != 0) {
proto_tree_add_item(reqresp_tree, (is_request) ? hf_imap_request : hf_imap_response, tvb, offset, linelen, ENC_ASCII|ENC_NA);
}
}
offset = next_offset; /* Skip over last line and \r\n at the end of it */
}
}
}
int
cmdline_parse_string(cmdline_parse_token_hdr_t *tk, const char *buf, void *res)
{
struct cmdline_token_string *tk2;
struct cmdline_token_string_data *sd;
unsigned int token_len;
const char *str;
if (!tk || !buf || ! *buf)
return -1;
tk2 = (struct cmdline_token_string *)tk;
sd = &tk2->string_data;
/* fixed string */
if (sd->str) {
str = sd->str;
do {
token_len = get_token_len(str);
/* if token is too big... */
if (token_len >= STR_TOKEN_SIZE - 1) {
continue;
}
if ( strncmp(buf, str, token_len) ) {
continue;
}
if ( !cmdline_isendoftoken(*(buf+token_len)) ) {
continue;
}
break;
} while ( (str = get_next_token(str)) != NULL );
if (!str)
return -1;
}
/* unspecified string */
else {
token_len = 0;
while(!cmdline_isendoftoken(buf[token_len]) &&
token_len < (STR_TOKEN_SIZE-1))
token_len++;
/* return if token too long */
if (token_len >= STR_TOKEN_SIZE - 1) {
return -1;
}
}
if (res) {
/* we are sure that token_len is < STR_TOKEN_SIZE-1 */
rte_snprintf(res, STR_TOKEN_SIZE, "%s", buf);
*((char *)res + token_len) = 0;
}
return token_len;
}
static wxString get_token_str( char* cur )
{
return wxString( cur, get_token_len( cur ) );
}
void CJSourceParser::AddClassNode( char*& cur )
{
char* ctxStart = cur;
wxString classkeyword = get_token_str( cur );
skip_token( cur ); // skip 'class' keyword
if ( !get_next_token( cur ) ) return;
// in C++
if ( *cur == ':' )
{
skip_token( cur );
get_next_token( cur );
}
// by default all class members are private
mCurVis = SP_VIS_PRIVATE;
spClass* pClass = new spClass();
if ( classkeyword == "class" )
pClass->mClassSubType = SP_CLTYPE_CLASS;
else if ( classkeyword == "struct" ) {
pClass->mClassSubType = SP_CLTYPE_STRUCTURE;
mCurVis = SP_VIS_PUBLIC;
}
else if ( classkeyword == "union" ) {
pClass->mClassSubType = SP_CLTYPE_UNION;
mCurVis = SP_VIS_PUBLIC;
}
else if ( classkeyword == "interface" )
pClass->mClassSubType = SP_CLTYPE_INTERFACE;
else {
pClass->mClassSubType = SP_CLTYPE_INVALID;
wxFAIL_MSG("unknown class keyword");
}
mpCurCtx->AddMember( pClass );
// attach comments about the class
AttachComments( *pClass, cur );
pClass->mSrcLineNo = get_line_no();
pClass->mSrcOffset = int( ctxStart - _gSrcStart );
char* nameTok = cur;
pClass->m_Name = get_token_str( cur );
bool isDerived = 0;
// DANGER-MACROS::
do
{
skip_token( cur );
if ( !get_next_token( cur ) ) return;
if ( *cur == ':' )
{
isDerived = 1;
char* tok = cur;
int tmpLn;
store_line_no( tmpLn );
skip_next_token_back( tok );
skip_token_back( tok );
restore_line_no( tmpLn );
// class name should precend ':' colon, thus
// the one which was captured before was
// proablty something else (like __dllexport MyClass : ... )
if ( nameTok != tok )
{
pClass->m_Name = get_token_str( tok );
}
}
if ( *cur == '{' )
break;
if ( *cur == ',' )
continue;
size_t len = get_token_len( cur );
// skip neglectable C++ modifieres
if ( cmp_tokens_fast( cur, "public", len ) )
continue;
if ( cmp_tokens_fast( cur, "protected", len ) )
continue;
if ( cmp_tokens_fast( cur, "private", len ) )
continue;
if ( cmp_tokens_fast( cur, "virtual", len ) )
continue;
// skip neglectable JAVA modifieres
if ( cmp_tokens_fast( cur, "extends", len ) )
{
isDerived = 1;
continue;
}
if ( cmp_tokens_fast( cur, "implements", len ) )
{
isDerived = 1;
continue;
}
// all we need to know is superclass or interface
char* tok = cur;
int tmpLn;
store_line_no( tmpLn );
skip_token(tok);
get_next_token(tok);
restore_line_no( tmpLn );
if ( *tok != ':' && *cur != ':' )
pClass->m_SuperClassNames.push_back( wxString( cur, len ) );
} while(1);
if ( !isDerived )
{
int tmpLn;
store_line_no( tmpLn );
while ( pClass->m_SuperClassNames.size() )
pClass->m_SuperClassNames.erase( &pClass->m_SuperClassNames[0] );
char* tok = cur;
// some non-obviouse token was following "class" keyword -
// we've confused it with class name - thus now we're reverting this mistake
skip_next_token_back( tok );
skip_token_back( tok );
pClass->m_Name = get_token_str( tok );
restore_line_no( tmpLn );
}
++cur; // skip opening curly brace
pClass->mHeaderLength = ( cur - ctxStart );
// now, enter the class context
mpCurCtx = pClass;
clear_commets_queue();
}
void CJSourceParser::ParseKeyword( char*& cur )
{
// analyze token, which identifies the begining of a new context
if ( CheckVisibilty( cur ) )
{
skip_token( cur );
return;
}
if ( is_class_token( cur ) )
{
if ( is_forward_decl( cur ) )
{
// forward declarations are ignored;
skip_token( cur );
return;
}
if ( mNestingLevel == 0 )
{
// change context form global class context
mCurCtxType = SP_CTX_CLASS;
}
++mNestingLevel;
// add information about new class (name, inheritance, etc)
AddClassNode( cur );
// the default visiblity for class members is 'private'
mCurVis = SP_VIS_PRIVATE;
return;
}
size_t len = get_token_len( cur );
if ( cmp_tokens_fast( cur, "typedef", len ) )
{
skip_token(cur);
get_next_token(cur);
if ( cmp_tokens_fast( cur, "struct", len ) ||
cmp_tokens_fast( cur, "union", len ) ||
cmp_tokens_fast( cur, "class", len )
)
{
if ( mNestingLevel == 0 )
{
// change context form global class context
mCurCtxType = SP_CTX_CLASS;
}
++mNestingLevel;
// add information about new class (name, inheritance, etc)
AddClassNode( cur );
// the default visiblity for class members is 'private'
mCurVis = SP_VIS_PRIVATE;
return;
// FOR NOW:: typedef struct, etc are also ignored
//skip_scope_block( cur );
}
if ( cmp_tokens_fast( cur, "enum", len ) )
{
AddEnumNode( cur );
return;
}
AddTypeDefNode( cur );
return;
}
if ( cmp_tokens_fast( cur, "enum", len ) )
{
AddEnumNode( cur );
return;
}
if ( cmp_tokens_fast( cur, "extern", len ) )
{
// extern's are ignored (both extern "C" and extern vars)
while ( *cur != '{' &&
*cur != ';' )
{
skip_token( cur );
get_next_token( cur );
}
return;
}
if ( cmp_tokens_fast( cur, "enum", len ) )
{
// enumeration blocks are ignored
skip_scope_block( cur );
get_next_token( cur );
skip_token( cur ); // skip ';' token;
return;
}
if ( cmp_tokens_fast( cur, "package", len ) )
{
// packages are ignored
skip_statement( cur );
return;
};
if ( cmp_tokens_fast( cur, "import", len ) )
{
// import statements are ignored
skip_statement( cur );
return;
}
if ( cmp_tokens_fast( cur, "virtual", len ) )
{
// probably the virtual method is in front of us;
mIsVirtual = 1;
skip_token( cur );
return;
}
if ( cmp_tokens_fast( cur, "template", len ) )
{
mIsTemplate = 1;
skip_tempalate_statement( cur );
return;
}
if ( cmp_tokens_fast( cur, "friend", len ) )
{
skip_statement( cur );
return;
}
// ingnore "unsigificant" tokens (i.e. which do not
// affect the current parsing context)
skip_token( cur );
}
static void
dissect_acap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
gboolean is_request;
proto_tree *acap_tree, *reqresp_tree;
proto_item *ti, *hidden_item;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
int tokenlen;
const guchar *next_token;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "ACAP");
/*
* Find the end of the first line.
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
if (pinfo->match_uint == pinfo->destport)
is_request = TRUE;
else
is_request = FALSE;
/*
* Put the first line from the buffer into the summary
* (but leave out the line terminator).
*/
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
if (tree) {
ti = proto_tree_add_item(tree, hfi_acap, tvb, offset, -1,
ENC_NA);
acap_tree = proto_item_add_subtree(ti, ett_acap);
if (is_request) {
hidden_item = proto_tree_add_boolean(acap_tree,
&hfi_acap_request, tvb, 0, 0, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
} else {
hidden_item = proto_tree_add_boolean(acap_tree,
&hfi_acap_response, tvb, 0, 0, TRUE);
PROTO_ITEM_SET_HIDDEN(hidden_item);
}
/*
* Put the line into the protocol tree.
*/
ti = proto_tree_add_format_text(acap_tree, tvb, offset, next_offset - offset);
reqresp_tree = proto_item_add_subtree(ti, ett_acap_reqresp);
/*
* Show the first line as tags + requests or replies.
*/
/*
* Extract the first token, and, if there is a first
* token, add it as the request or reply tag.
*/
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
if (is_request) {
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Request Tag: %s",
format_text(line, tokenlen));
} else {
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Response Tag: %s",
format_text(line, tokenlen));
}
offset += (int)(next_token - line);
linelen -= (int)(next_token - line);
line = next_token;
}
/*
* Add the rest of the line as request or reply data.
*/
if (linelen != 0) {
if (is_request) {
proto_tree_add_text(reqresp_tree, tvb, offset,
linelen, "Request: %s",
format_text(line, linelen));
} else {
proto_tree_add_text(reqresp_tree, tvb, offset,
linelen, "Response: %s",
format_text(line, linelen));
}
}
/*
* XXX - show the rest of the frame; this requires that
* we handle literals, quoted strings, continuation
* responses, etc..
*
* This involves a state machine, and attaching
* state information to the packets.
*/
}
}
int
cmdline_parse_string(cmdline_parse_token_hdr_t *tk, const char *buf, void *res,
unsigned ressize)
{
struct cmdline_token_string *tk2;
struct cmdline_token_string_data *sd;
unsigned int token_len;
const char *str;
if (res && ressize < STR_TOKEN_SIZE)
return -1;
if (!tk || !buf || ! *buf)
return -1;
tk2 = (struct cmdline_token_string *)tk;
sd = &tk2->string_data;
/* fixed string (known single token) */
if ((sd->str != NULL) && (strcmp(sd->str, TOKEN_STRING_MULTI) != 0)) {
str = sd->str;
do {
token_len = get_token_len(str);
/* if token is too big... */
if (token_len >= STR_TOKEN_SIZE - 1) {
continue;
}
if ( strncmp(buf, str, token_len) ) {
continue;
}
if ( !cmdline_isendoftoken(*(buf+token_len)) ) {
continue;
}
break;
} while ( (str = get_next_token(str)) != NULL );
if (!str)
return -1;
}
/* multi string */
else if (sd->str != NULL) {
if (ressize < STR_MULTI_TOKEN_SIZE)
return -1;
token_len = 0;
while (!cmdline_isendofcommand(buf[token_len]) &&
token_len < (STR_MULTI_TOKEN_SIZE - 1))
token_len++;
/* return if token too long */
if (token_len >= (STR_MULTI_TOKEN_SIZE - 1))
return -1;
}
/* unspecified string (unknown single token) */
else {
token_len = 0;
while(!cmdline_isendoftoken(buf[token_len]) &&
token_len < (STR_TOKEN_SIZE-1))
token_len++;
/* return if token too long */
if (token_len >= STR_TOKEN_SIZE - 1) {
return -1;
}
}
if (res) {
if ((sd->str != NULL) && (strcmp(sd->str, TOKEN_STRING_MULTI) == 0))
/* we are sure that token_len is < STR_MULTI_TOKEN_SIZE-1 */
snprintf(res, STR_MULTI_TOKEN_SIZE, "%s", buf);
else
/* we are sure that token_len is < STR_TOKEN_SIZE-1 */
snprintf(res, STR_TOKEN_SIZE, "%s", buf);
*((char *)res + token_len) = 0;
}
return token_len;
}
static gboolean
dissect_kismet(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
{
gboolean is_request;
gboolean is_continuation;
proto_tree *kismet_tree=NULL, *reqresp_tree=NULL;
proto_item *ti;
proto_item *tmp_item;
gint offset = 0;
const guchar *line;
gint next_offset;
int linelen;
int tokenlen;
int i;
const guchar *next_token;
/*
* Find the end of the first line.
*
* Note that "tvb_find_line_end()" will return a value that is
* not longer than what's in the buffer, so the "tvb_get_ptr()"
* call won't throw an exception.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
line = tvb_get_ptr(tvb, offset, linelen);
/*
* Check if it is an ASCII based protocol with reasonable length
* packets, if not return, and try annother dissector.
*/
if (linelen < 8) {
/*
* Packet is too short
*/
return FALSE;
} else {
for (i = 0; i < 8; ++i) {
/*
* Packet contains non-ASCII data
*/
if (line[i] < 32 || line[i] > 128)
return FALSE;
}
}
/*
* If it is Kismet traffic set COL_PROTOCOL.
*/
col_set_str(pinfo->cinfo, COL_PROTOCOL, "kismet");
/*
* Check if it is request, reply or continuation.
*/
if (pinfo->match_port == pinfo->destport) {
is_request = TRUE;
is_continuation = FALSE;
} else {
is_request = FALSE;
is_continuation = response_is_continuation (line);
}
if (check_col(pinfo->cinfo, COL_INFO)) {
/*
* Put the first line from the buffer into the summary
* if it's a kismet request or reply (but leave out the
* line terminator).
* Otherwise, just call it a continuation.
*/
if (is_continuation)
col_set_str(pinfo->cinfo, COL_INFO, "Continuation");
else
col_add_fstr(pinfo->cinfo, COL_INFO, "%s: %s",
is_request ? "Request" : "Response",
format_text(line, linelen));
}
if (tree) {
ti = proto_tree_add_item(tree, proto_kismet, tvb, offset, -1, FALSE);
kismet_tree = proto_item_add_subtree(ti, ett_kismet);
}
if (is_continuation) {
/*
* Put the whole packet into the tree as data.
*/
call_dissector(data_handle, tvb, pinfo, kismet_tree);
return TRUE;
}
if (is_request) {
tmp_item = proto_tree_add_boolean(kismet_tree,
hf_kismet_request, tvb, 0, 0, TRUE);
} else {
tmp_item = proto_tree_add_boolean(kismet_tree,
hf_kismet_response, tvb, 0, 0, TRUE);
}
PROTO_ITEM_SET_GENERATED (tmp_item);
while (tvb_offset_exists(tvb, offset)) {
/*
* Find the end of the line.
*/
linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, FALSE);
if (linelen) {
/*
* Put this line.
*/
ti = proto_tree_add_text(kismet_tree, tvb, offset,
next_offset - offset, "%s",
tvb_format_text(tvb, offset,
next_offset - offset - 1));
reqresp_tree = proto_item_add_subtree(ti, ett_kismet_reqresp);
tokenlen = get_token_len(line, line + linelen, &next_token);
if (tokenlen != 0) {
guint8 *reqresp;
reqresp = tvb_get_ephemeral_string(tvb, offset, tokenlen);
if (is_request) {
/*
* No request dissection
*/
} else {
/*
* *KISMET: {Version} {Start time} \001{Server name}\001 {Build Revision}
* two fields left undocumented: {???} {?ExtendedVersion?}
*/
if (!strncmp(reqresp, "*KISMET", 7)) {
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Kismet version: %s",
format_text(line, tokenlen));
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Start time: %s",
format_text(line, tokenlen));
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Server name: %s",
format_text(line + 1, tokenlen - 2));
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Build revision: %s",
format_text(line, tokenlen));
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Unknown field: %s",
format_text(line, tokenlen));
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen,
"Extended version string: %s",
format_text(line, tokenlen));
}
/*
* *TIME: {Time}
*/
if (!strncmp(reqresp, "*TIME", 5)) {
time_t t;
char *ptr;
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
tokenlen = get_token_len(line, line + linelen, &next_token);
/*
* Convert form ascii to time_t
*/
t = atoi(format_text (line, tokenlen));
/*
* Format ascii representaion of time
*/
ptr = abs_time_secs_to_str(t, ABSOLUTE_TIME_LOCAL, TRUE);
proto_tree_add_text(reqresp_tree, tvb, offset,
tokenlen, "Time: %s", ptr);
}
}
offset += (gint) (next_token - line);
linelen -= (int) (next_token - line);
line = next_token;
}
}
offset = next_offset;
}
return TRUE;
}
static int SdpMedia(const char *data, int len, sdp_msg *msg)
{
const char *next_token;
const char *lineend;
char number[256];
int tokenlen, token;
short mcnt;
mcnt = msg->transp.count;
if (mcnt == SDP_MAX_RTP_CHANNELS)
return -1;
lineend = data + len;
/* The first token media type */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || data[tokenlen] != ' ') {
return -1;
}
msg->transp.type[mcnt] = SDP_MEDIA_UNKNOW;
if (strncmp(data, "audio", tokenlen) == 0) {
msg->transp.type[mcnt] = SDP_MEDIA_AUDIO;
}
else if (strncmp(data, "video", tokenlen) == 0) {
msg->transp.type[mcnt] = SDP_MEDIA_VIDEO;
}
else {
LogPrintf(LV_WARNING, "New media type");
}
data = next_token;
/* port */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || data[tokenlen] != ' ') {
return -1;
}
token = find_chr(data, tokenlen, '/');
if (token != -1) {
memcpy(number, data, token);
number[token] = '\0';
msg->transp.port[mcnt] = atoi(number);
LogPrintf(LV_WARNING, "Port count to be complete");
}
else {
msg->transp.port[mcnt] = atoi(data);
}
data = next_token;
/* media protocol */
tokenlen = get_token_len(data, lineend, &next_token);
if (tokenlen == 0 || data[tokenlen] != ' ') {
return -1;
}
msg->transp.proto[mcnt] = DMemMalloc(tokenlen+1);
memcpy(msg->transp.proto[mcnt], data, tokenlen);
msg->transp.proto[mcnt][tokenlen] = '\0';
data = next_token;
/* pt */
tokenlen = get_token_len(data, lineend, &next_token);
if (strcmp(msg->transp.proto[mcnt], "RTP/AVP") == 0) {
while (tokenlen != 0) {
#if 0
memcpy(number, data, tokenlen);
number[tokenlen] = '\0';
msg->transp.media[mcnt].pt[msg->transp.media[mcnt].pt_count] = atoi(number);
#else
msg->transp.media[mcnt].pt[msg->transp.media[mcnt].pt_count] = atoi(data);
#endif
msg->transp.media[mcnt].pt_count++;
data = next_token;
tokenlen = get_token_len(data, lineend, &next_token);
}
}
msg->transp.count++;
return 0;
}
