static gboolean proto_tree_model_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter) { /* optimized version of: * return proto_tree_model_iter_n_children(tree_model, iter) != 0; * synchronize when changed! */ ProtoTreeModel *model; proto_node *node; g_return_val_if_fail(PROTO_IS_TREE(tree_model), FALSE); model = (ProtoTreeModel *) tree_model; g_return_val_if_fail(iter == NULL || iter->user_data != NULL, FALSE); if (iter) { g_return_val_if_fail(iter->stamp == model->stamp, FALSE); node = (proto_node *)iter->user_data; } else node = model->protocol_tree; if (!node) return FALSE; node = node->first_child; while (node != NULL) { if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(node)) return TRUE; node = node->next; } return FALSE; }
static gint proto_tree_model_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter) { ProtoTreeModel *model; proto_node *node; gint count; g_return_val_if_fail(PROTO_IS_TREE(tree_model), 0); model = (ProtoTreeModel *) tree_model; g_return_val_if_fail(iter == NULL || iter->user_data != NULL, 0); if (iter) { g_return_val_if_fail(iter->stamp == model->stamp, 0); node = (proto_node *)iter->user_data; } else node = model->protocol_tree; if (!node) return 0; count = 0; node = node->first_child; while (node != NULL) { if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(node)) count++; node = node->next; } return count; }
QString ProtoNode::labelText() const { if (!node_) { return QString(); } field_info *fi = PNODE_FINFO(node_); if (!fi) { return QString(); } QString label; /* was a free format label produced? */ if (fi->rep) { label = fi->rep->representation; } else { /* no, make a generic label */ gchar label_str[ITEM_LABEL_LENGTH]; proto_item_fill_label(fi, label_str); label = label_str; } // Generated takes precedence. if (PROTO_ITEM_IS_GENERATED(node_)) { label.prepend("["); label.append("]"); } if (PROTO_ITEM_IS_HIDDEN(node_)) { label.prepend("<"); label.append(">"); } return label; }
static GtkTreePath * proto_tree_model_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter) { ProtoTreeModel *model; GtkTreePath *path; proto_node *node; g_return_val_if_fail(PROTO_IS_TREE(tree_model), NULL); model = (ProtoTreeModel *) tree_model; g_return_val_if_fail(iter != NULL, NULL); g_return_val_if_fail(iter->stamp == model->stamp, NULL); node = (proto_node *)iter->user_data; g_return_val_if_fail(node != model->protocol_tree, NULL); path = gtk_tree_path_new(); do { proto_node *cur = node; proto_node *node_i; int pos; node = node->parent; pos = 0; for (node_i = node->first_child; node_i; node_i = node_i->next) { if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(node_i)) { if (node_i == cur) break; pos++; } } g_assert(node_i != NULL); gtk_tree_path_prepend_index(path, pos); } while (node != model->protocol_tree); return path; }
static gboolean proto_tree_model_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter) { ProtoTreeModel *model; proto_node *current; g_return_val_if_fail(PROTO_IS_TREE(tree_model), FALSE); model = (ProtoTreeModel *) tree_model; g_return_val_if_fail(iter->stamp == model->stamp, FALSE); current = (proto_node *)iter->user_data; current = current->next; while (current) { if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(current)) { iter->user_data = current; return TRUE; } current = current->next; } return FALSE; }
static gboolean proto_tree_model_iter_nth_child(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n) { ProtoTreeModel *model; proto_node *node; g_return_val_if_fail(PROTO_IS_TREE(tree_model), FALSE); model = (ProtoTreeModel *) tree_model; if (parent) { g_return_val_if_fail(parent->stamp == model->stamp, FALSE); node = (proto_node *)parent->user_data; } else node = model->protocol_tree; if (!node) return FALSE; node = node->first_child; while (node != NULL) { if (model->with_hidden || !PROTO_ITEM_IS_HIDDEN(node)) { if (!n) break; n--; } node = node->next; } /* not found? */ if (!node) return FALSE; iter->stamp = model->stamp; iter->user_data = node; return TRUE; }
/* Fill a single protocol tree item with its string value and set its color. */ static void proto_tree_draw_node(proto_node *node, gpointer data) { field_info *fi = PNODE_FINFO(node); gchar label_str[ITEM_LABEL_LENGTH]; gchar *label_ptr; gboolean is_branch; /* dissection with an invisible proto tree? */ g_assert(fi); if (PROTO_ITEM_IS_HIDDEN(node) && !prefs.display_hidden_proto_items) return; // Fill in our label /* was a free format label produced? */ if (fi->rep) { label_ptr = fi->rep->representation; } else { /* no, make a generic label */ label_ptr = label_str; proto_item_fill_label(fi, label_str); } if (node->first_child != NULL) { is_branch = TRUE; g_assert(fi->tree_type >= 0 && fi->tree_type < num_tree_types); } else { is_branch = FALSE; } if (PROTO_ITEM_IS_GENERATED(node)) { if (PROTO_ITEM_IS_HIDDEN(node)) { label_ptr = g_strdup_printf("<[%s]>", label_ptr); } else { label_ptr = g_strdup_printf("[%s]", label_ptr); } } else if (PROTO_ITEM_IS_HIDDEN(node)) { label_ptr = g_strdup_printf("<%s>", label_ptr); } QTreeWidgetItem *parentItem = (QTreeWidgetItem *)data; QTreeWidgetItem *item; ProtoTree *proto_tree = qobject_cast<ProtoTree *>(parentItem->treeWidget()); item = new QTreeWidgetItem(parentItem, 0); // Set our colors. QPalette pal = QApplication::palette(); if (fi && fi->hfinfo) { if(fi->hfinfo->type == FT_PROTOCOL) { item->setData(0, Qt::BackgroundRole, pal.alternateBase()); } if((fi->hfinfo->type == FT_FRAMENUM) || (FI_GET_FLAG(fi, FI_URL) && IS_FT_STRING(fi->hfinfo->type))) { QFont font = item->font(0); item->setData(0, Qt::ForegroundRole, pal.link()); font.setUnderline(true); item->setData(0, Qt::FontRole, font); if (fi->hfinfo->type == FT_FRAMENUM) { proto_tree->emitRelatedFrame(fi->value.value.uinteger); } } } // XXX - Add routines to get our severity colors. if(FI_GET_FLAG(fi, PI_SEVERITY_MASK)) { switch(FI_GET_FLAG(fi, PI_SEVERITY_MASK)) { case(PI_COMMENT): item->setData(0, Qt::BackgroundRole, expert_color_comment); break; case(PI_CHAT): item->setData(0, Qt::BackgroundRole, expert_color_chat); break; case(PI_NOTE): item->setData(0, Qt::BackgroundRole, expert_color_note); break; case(PI_WARN): item->setData(0, Qt::BackgroundRole, expert_color_warn); break; case(PI_ERROR): item->setData(0, Qt::BackgroundRole, expert_color_error); break; default: g_assert_not_reached(); } item->setData(0, Qt::ForegroundRole, expert_color_foreground); } item->setText(0, label_ptr); item->setData(0, Qt::UserRole, qVariantFromValue(fi)); if (PROTO_ITEM_IS_GENERATED(node) || PROTO_ITEM_IS_HIDDEN(node)) { g_free(label_ptr); } if (is_branch) { if (tree_expanded(fi->tree_type)) { item->setExpanded(true); } else { item->setExpanded(false); } proto_tree_children_foreach(node, proto_tree_draw_node, item); } }
/* Write out a tree's data, and any child nodes, as PDML */ static void proto_tree_write_node_pdml(proto_node *node, gpointer data) { field_info *fi = PNODE_FINFO(node); write_pdml_data *pdata = (write_pdml_data*) data; const gchar *label_ptr; gchar label_str[ITEM_LABEL_LENGTH]; char *dfilter_string; size_t chop_len; int i; gboolean wrap_in_fake_protocol; g_assert(fi && "dissection with an invisible proto tree?"); /* Will wrap up top-level field items inside a fake protocol wrapper to preserve the PDML schema */ wrap_in_fake_protocol = (((fi->hfinfo->type != FT_PROTOCOL) || (fi->hfinfo->id == proto_data)) && (pdata->level == 0)); /* Indent to the correct level */ for (i = -1; i < pdata->level; i++) { fputs(" ", pdata->fh); } if (wrap_in_fake_protocol) { /* Open fake protocol wrapper */ fputs("<proto name=\"fake-field-wrapper\">\n", pdata->fh); /* Indent to increased level before writint out field */ pdata->level++; for (i = -1; i < pdata->level; i++) { fputs(" ", pdata->fh); } } /* Text label. It's printed as a field with no name. */ if (fi->hfinfo->id == hf_text_only) { /* Get the text */ if (fi->rep) { label_ptr = fi->rep->representation; } else { label_ptr = ""; } /* Show empty name since it is a required field */ fputs("<field name=\"", pdata->fh); fputs("\" show=\"", pdata->fh); print_escaped_xml(pdata->fh, label_ptr); fprintf(pdata->fh, "\" size=\"%d", fi->length); fprintf(pdata->fh, "\" pos=\"%d", fi->start); fputs("\" value=\"", pdata->fh); write_pdml_field_hex_value(pdata, fi); if (node->first_child != NULL) { fputs("\">\n", pdata->fh); } else { fputs("\"/>\n", pdata->fh); } } /* Uninterpreted data, i.e., the "Data" protocol, is * printed as a field instead of a protocol. */ else if (fi->hfinfo->id == proto_data) { /* Write out field with data */ fputs("<field name=\"data\" value=\"", pdata->fh); write_pdml_field_hex_value(pdata, fi); fputs("\"/>\n", pdata->fh); } /* Normal protocols and fields */ else { if (fi->hfinfo->type == FT_PROTOCOL) { fputs("<proto name=\"", pdata->fh); } else { fputs("<field name=\"", pdata->fh); } print_escaped_xml(pdata->fh, fi->hfinfo->abbrev); #if 0 /* PDML spec, see: * http://www.nbee.org/doku.php?id=netpdl:pdml_specification * * the show fields contains things in 'human readable' format * showname: contains only the name of the field * show: contains only the data of the field * showdtl: contains additional details of the field data * showmap: contains mappings of the field data (e.g. the hostname to an IP address) * * XXX - the showname shouldn't contain the field data itself * (like it's contained in the fi->rep->representation). * Unfortunately, we don't have the field data representation for * all fields, so this isn't currently possible */ fputs("\" showname=\"", pdata->fh); print_escaped_xml(pdata->fh, fi->hfinfo->name); #endif if (fi->rep) { fputs("\" showname=\"", pdata->fh); print_escaped_xml(pdata->fh, fi->rep->representation); } else { label_ptr = label_str; proto_item_fill_label(fi, label_str); fputs("\" showname=\"", pdata->fh); print_escaped_xml(pdata->fh, label_ptr); } if (PROTO_ITEM_IS_HIDDEN(node)) fprintf(pdata->fh, "\" hide=\"yes"); fprintf(pdata->fh, "\" size=\"%d", fi->length); fprintf(pdata->fh, "\" pos=\"%d", fi->start); /* fprintf(pdata->fh, "\" id=\"%d", fi->hfinfo->id);*/ /* show, value, and unmaskedvalue attributes */ switch (fi->hfinfo->type) { case FT_PROTOCOL: break; case FT_NONE: fputs("\" show=\"\" value=\"", pdata->fh); break; default: /* XXX - this is a hack until we can just call * fvalue_to_string_repr() for *all* FT_* types. */ dfilter_string = proto_construct_match_selected_string(fi, pdata->edt); if (dfilter_string != NULL) { chop_len = strlen(fi->hfinfo->abbrev) + 4; /* for " == " */ /* XXX - Remove double-quotes. Again, once we * can call fvalue_to_string_repr(), we can * ask it not to produce the version for * display-filters, and thus, no * double-quotes. */ if (dfilter_string[strlen(dfilter_string)-1] == '"') { dfilter_string[strlen(dfilter_string)-1] = '\0'; chop_len++; } fputs("\" show=\"", pdata->fh); print_escaped_xml(pdata->fh, &dfilter_string[chop_len]); } /* * XXX - should we omit "value" for any fields? * What should we do for fields whose length is 0? * They might come from a pseudo-header or from * the capture header (e.g., time stamps), or * they might be generated fields. */ if (fi->length > 0) { fputs("\" value=\"", pdata->fh); if (fi->hfinfo->bitmask!=0) { fprintf(pdata->fh, "%X", fvalue_get_uinteger(&fi->value)); fputs("\" unmaskedvalue=\"", pdata->fh); write_pdml_field_hex_value(pdata, fi); } else { write_pdml_field_hex_value(pdata, fi); } } } if (node->first_child != NULL) { fputs("\">\n", pdata->fh); } else if (fi->hfinfo->id == proto_data) { fputs("\">\n", pdata->fh); } else { fputs("\"/>\n", pdata->fh); } } /* We always print all levels for PDML. Recurse here. */ if (node->first_child != NULL) { pdata->level++; proto_tree_children_foreach(node, proto_tree_write_node_pdml, pdata); pdata->level--; } /* Take back the extra level we added for fake wrapper protocol */ if (wrap_in_fake_protocol) { pdata->level--; } if (node->first_child != NULL) { /* Indent to correct level */ for (i = -1; i < pdata->level; i++) { fputs(" ", pdata->fh); } /* Close off current element */ if (fi->hfinfo->id != proto_data) { /* Data protocol uses simple tags */ if (fi->hfinfo->type == FT_PROTOCOL) { fputs("</proto>\n", pdata->fh); } else { fputs("</field>\n", pdata->fh); } } } /* Close off fake wrapper protocol */ if (wrap_in_fake_protocol) { fputs("</proto>\n", pdata->fh); } }
/* Print a tree's data, and any child nodes. */ static void proto_tree_print_node(proto_node *node, gpointer data) { field_info *fi = PNODE_FINFO(node); print_data *pdata = (print_data*) data; const guint8 *pd; gchar label_str[ITEM_LABEL_LENGTH]; gchar *label_ptr; __android_log_print(ANDROID_LOG_INFO, "libtshark", "in proto_tree_print_node !"); g_assert(fi && "dissection with an invisible proto tree?"); /* Don't print invisible entries. */ if (PROTO_ITEM_IS_HIDDEN(node)) return; __android_log_print(ANDROID_LOG_INFO, "libtshark", "the proto tree is not invisible"); /* Give up if we've already gotten an error. */ if (!pdata->success) return; __android_log_print(ANDROID_LOG_INFO, "libtshark", "success so far"); /* was a free format label produced? */ if (fi->rep) { label_ptr = fi->rep->representation; __android_log_print(ANDROID_LOG_INFO, "libtshark", "free format"); } else { /* no, make a generic label */ __android_log_print(ANDROID_LOG_INFO, "libtshark", "generic label"); label_ptr = label_str; proto_item_fill_label(fi, label_str); } __android_log_print(ANDROID_LOG_INFO, "libtshark", "A-OK"); if (PROTO_ITEM_IS_GENERATED(node)) { label_ptr = g_strdup_printf("[%s]", label_ptr); } __android_log_print(ANDROID_LOG_INFO, "libtshark", "proto was generated"); //if (!print_line(pdata->stream, pdata->level, label_ptr)) { // pdata->success = FALSE; // return; //} __android_log_print(ANDROID_LOG_INFO, "libtshark", "line: %s", label_ptr); __android_log_print(ANDROID_LOG_INFO, "libtshark", "line is printed"); if (PROTO_ITEM_IS_GENERATED(node)) { g_free(label_ptr); } __android_log_print(ANDROID_LOG_INFO, "libtshark", "item is generated"); /* If it's uninterpreted data, dump it (unless our caller will be printing the entire packet in hex). */ if (fi->hfinfo->id == proto_data && pdata->print_hex_for_data) { /* * Find the data for this field. */ pd = get_field_data(pdata->src_list, fi); __android_log_print(ANDROID_LOG_INFO, "libtshark", "uninterpreted"); if (pd) { if (!print_hex_data_buffer(pdata->stream, pd, fi->length, pdata->encoding)) { pdata->success = FALSE; return; } } } __android_log_print(ANDROID_LOG_INFO, "libtshark", "getting ready to traverse all subtrees"); /* If we're printing all levels, or if this node is one with a subtree and its subtree is expanded, recurse into the subtree, if it exists. */ g_assert(fi->tree_type >= -1 && fi->tree_type < num_tree_types); __android_log_print(ANDROID_LOG_INFO, "libtshark", "passed the assert"); if (pdata->print_dissections == print_dissections_expanded || (pdata->print_dissections == print_dissections_as_displayed && fi->tree_type >= 0 && tree_is_expanded[fi->tree_type])) { __android_log_print(ANDROID_LOG_INFO, "libtshark", "made it in"); if (node->first_child != NULL) { __android_log_print(ANDROID_LOG_INFO, "libtshark", "and we're about to level up"); pdata->level++; __android_log_print(ANDROID_LOG_INFO, "libtshark", "for each child..."); proto_tree_children_foreach(node, proto_tree_print_node, pdata); pdata->level--; if (!pdata->success) return; } } }
bool ProtoNode::isHidden(proto_node * node) { return PROTO_ITEM_IS_HIDDEN(node) && !prefs.display_hidden_proto_items; }
/* Print a tree's data, and any child nodes. */ static void proto_tree_print_node(proto_node *node, gpointer data) { field_info *fi = PNODE_FINFO(node); print_data *pdata = (print_data*) data; const guint8 *pd; gchar label_str[ITEM_LABEL_LENGTH]; gchar *label_ptr; /* dissection with an invisible proto tree? */ g_assert(fi); /* Don't print invisible entries. */ if (PROTO_ITEM_IS_HIDDEN(node)) return; /* Give up if we've already gotten an error. */ if (!pdata->success) return; /* was a free format label produced? */ if (fi->rep) { label_ptr = fi->rep->representation; } else { /* no, make a generic label */ label_ptr = label_str; proto_item_fill_label(fi, label_str); } if (PROTO_ITEM_IS_GENERATED(node)) { label_ptr = g_strdup_printf("[%s]", label_ptr); } if (!print_line(pdata->stream, pdata->level, label_ptr)) { pdata->success = FALSE; return; } /* * If -O is specified, only display the protocols which are in the * lookup table. Only check on the first level: once we start printing * a tree, print the rest of the subtree. Otherwise we won't print * subitems whose abbreviation doesn't match the protocol--for example * text items (whose abbreviation is simply "text"). */ if (output_only_tables != NULL && pdata->level == 0 && g_hash_table_lookup(output_only_tables, fi->hfinfo->abbrev) == NULL) { pdata->success = TRUE; return; } if (PROTO_ITEM_IS_GENERATED(node)) { g_free(label_ptr); } /* If it's uninterpreted data, dump it (unless our caller will be printing the entire packet in hex). */ if (fi->hfinfo->id == proto_data && pdata->print_hex_for_data) { /* * Find the data for this field. */ pd = get_field_data(pdata->src_list, fi); if (pd) { if (!print_line(pdata->stream, 0, "")) { pdata->success = FALSE; return; } if (!print_hex_data_buffer(pdata->stream, pd, fi->length, pdata->encoding)) { pdata->success = FALSE; return; } } } /* If we're printing all levels, or if this node is one with a subtree and its subtree is expanded, recurse into the subtree, if it exists. */ g_assert(fi->tree_type >= -1 && fi->tree_type < num_tree_types); if (pdata->print_dissections == print_dissections_expanded || (pdata->print_dissections == print_dissections_as_displayed && fi->tree_type >= 0 && tree_is_expanded[fi->tree_type])) { if (node->first_child != NULL) { pdata->level++; proto_tree_children_foreach(node, proto_tree_print_node, pdata); pdata->level--; if (!pdata->success) return; } } }