print.c

   1 /* print.c
   2  * Routines for printing packet analysis trees.
   3  *
   4  * $Id$
   5  *
   6  * Gilbert Ramirez <gram@alumni.rice.edu>
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include <epan/epan.h>
  35 #include <epan/epan_dissect.h>
  36 #include <epan/tvbuff.h>
  37 #include <epan/packet.h>
  38
  39 #include "packet-range.h"
  40 #include "print.h"
  41 #include "ps.h"
  42 #include "file_util.h"
  43 #include <epan/charsets.h>
  44 #include <epan/dissectors/packet-data.h>
  45 #include <epan/dissectors/packet-frame.h>
  46
  47 #define PDML_VERSION "0"
  48 #define PSML_VERSION "0"
  49
  50 typedef struct {
  51         int                     level;
  52         print_stream_t          *stream;
  53         gboolean                success;
  54         GSList                  *src_list;
  55         print_dissections_e     print_dissections;
  56         gboolean                print_hex_for_data;
  57         char_enc                encoding;
  58         epan_dissect_t          *edt;
  59 } print_data;
  60
  61 typedef struct {
  62         int                     level;
  63         FILE                    *fh;
  64         GSList                  *src_list;
  65         epan_dissect_t          *edt;
  66 } write_pdml_data;
  67
  68 static void proto_tree_print_node(proto_node *node, gpointer data);
  69 static void proto_tree_write_node_pdml(proto_node *node, gpointer data);
  70 static const guint8 *get_field_data(GSList *src_list, field_info *fi);
  71 static void write_pdml_field_hex_value(write_pdml_data *pdata, field_info *fi);
  72 static gboolean print_hex_data_buffer(print_stream_t *stream, const guchar *cp,
  73     guint length, char_enc encoding);
  74 static void ps_clean_string(unsigned char *out, const unsigned char *in,
  75                         int outbuf_size);
  76 static void print_escaped_xml(FILE *fh, const char *unescaped_string);
  77
  78 static void print_pdml_geninfo(proto_tree *tree, FILE *fh);
  79
  80 static FILE *
  81 open_print_dest(int to_file, const char *dest)
  82 {
  83         FILE    *fh;
  84
  85         /* Open the file or command for output */
  86         if (to_file)
  87                 fh = eth_fopen(dest, "w");
  88         else
  89                 fh = popen(dest, "w");
  90
  91         return fh;
  92 }
  93
  94 static gboolean
  95 close_print_dest(int to_file, FILE *fh)
  96 {
  97         /* Close the file or command */
  98         if (to_file)
  99                 return (fclose(fh) == 0);
 100         else
 101                 return (pclose(fh) == 0);
 102 }
 103
 104 #define MAX_PS_LINE_LENGTH 256
 105
 106 gboolean
 107 proto_tree_print(print_args_t *print_args, epan_dissect_t *edt,
 108     print_stream_t *stream)
 109 {
 110         print_data data;
 111
 112         /* Create the output */
 113         data.level = 0;
 114         data.stream = stream;
 115         data.success = TRUE;
 116         data.src_list = edt->pi.data_src;
 117         data.encoding = edt->pi.fd->flags.encoding;
 118         data.print_dissections = print_args->print_dissections;
 119         /* If we're printing the entire packet in hex, don't
 120            print uninterpreted data fields in hex as well. */
 121         data.print_hex_for_data = !print_args->print_hex;
 122         data.edt = edt;
 123
 124         proto_tree_children_foreach(edt->tree, proto_tree_print_node, &data);
 125         return data.success;
 126 }
 127
 128 #define MAX_INDENT      160
 129
 130 /* Print a tree's data, and any child nodes. */
 131 static
 132 void proto_tree_print_node(proto_node *node, gpointer data)
 133 {
 134         field_info      *fi = PITEM_FINFO(node);
 135         print_data      *pdata = (print_data*) data;
 136         const guint8    *pd;
 137         gchar           label_str[ITEM_LABEL_LENGTH];
 138         gchar           *label_ptr;
 139
 140         /* Don't print invisible entries. */
 141         if (PROTO_ITEM_IS_HIDDEN(node))
 142                 return;
 143
 144         /* Give up if we've already gotten an error. */
 145         if (!pdata->success)
 146                 return;
 147
 148         /* was a free format label produced? */
 149         if (fi->rep) {
 150                 label_ptr = fi->rep->representation;
 151         }
 152         else { /* no, make a generic label */
 153                 label_ptr = label_str;
 154                 proto_item_fill_label(fi, label_str);
 155         }
 156
 157     if(PROTO_ITEM_IS_GENERATED(node)) {
 158         label_ptr = g_strdup_printf("[%s]", label_ptr);
 159     }
 160
 161         if (!print_line(pdata->stream, pdata->level, label_ptr)) {
 162                 pdata->success = FALSE;
 163                 return;
 164         }
 165
 166     if(PROTO_ITEM_IS_GENERATED(node)) {
 167         g_free(label_ptr);
 168     }
 169
 170         /* If it's uninterpreted data, dump it (unless our caller will
 171            be printing the entire packet in hex). */
 172         if (fi->hfinfo->id == proto_data && pdata->print_hex_for_data) {
 173                 /*
 174                  * Find the data for this field.
 175                  */
 176                 pd = get_field_data(pdata->src_list, fi);
 177                 if (pd) {
 178                         if (!print_hex_data_buffer(pdata->stream, pd,
 179                             fi->length, pdata->encoding)) {
 180                                 pdata->success = FALSE;
 181                                 return;
 182                         }
 183                 }
 184         }
 185
 186         /* If we're printing all levels, or if this node is one with a
 187            subtree and its subtree is expanded, recurse into the subtree,
 188            if it exists. */
 189         g_assert(fi->tree_type >= -1 && fi->tree_type < num_tree_types);
 190         if (pdata->print_dissections == print_dissections_expanded ||
 191             (pdata->print_dissections == print_dissections_as_displayed &&
 192                 fi->tree_type >= 0 && tree_is_expanded[fi->tree_type])) {
 193                 if (node->first_child != NULL) {
 194                         pdata->level++;
 195                         proto_tree_children_foreach(node,
 196                                 proto_tree_print_node, pdata);
 197                         pdata->level--;
 198                         if (!pdata->success)
 199                                 return;
 200                 }
 201         }
 202 }
 203
 204 void
 205 write_pdml_preamble(FILE *fh)
 206 {
 207         fputs("<?xml version=\"1.0\"?>\n", fh);
 208         fputs("<pdml version=\"" PDML_VERSION "\" ", fh);
 209         fprintf(fh, "creator=\"%s/%s\">\n", PACKAGE, VERSION);
 210 }
 211
 212 void
 213 proto_tree_write_pdml(epan_dissect_t *edt, FILE *fh)
 214 {
 215         write_pdml_data data;
 216
 217         /* Create the output */
 218         data.level = 0;
 219         data.fh = fh;
 220         data.src_list = edt->pi.data_src;
 221         data.edt = edt;
 222
 223         fprintf(fh, "<packet>\n");
 224
 225         /* Print a "geninfo" protocol as required by PDML */
 226         print_pdml_geninfo(edt->tree, fh);
 227
 228         proto_tree_children_foreach(edt->tree, proto_tree_write_node_pdml,
 229             &data);
 230
 231         fprintf(fh, "</packet>\n\n");
 232 }
 233
 234 /* Write out a tree's data, and any child nodes, as PDML */
 235 static void
 236 proto_tree_write_node_pdml(proto_node *node, gpointer data)
 237 {
 238         field_info      *fi = PITEM_FINFO(node);
 239         write_pdml_data *pdata = (write_pdml_data*) data;
 240         const gchar     *label_ptr;
 241         gchar           label_str[ITEM_LABEL_LENGTH];
 242         char            *dfilter_string;
 243         int             chop_len;
 244         int             i;
 245
 246         for (i = -1; i < pdata->level; i++) {
 247                 fputs("  ", pdata->fh);
 248         }
 249
 250         /* Text label. It's printed as a field with no name. */
 251         if (fi->hfinfo->id == hf_text_only) {
 252                 /* Get the text */
 253                 if (fi->rep) {
 254                         label_ptr = fi->rep->representation;
 255                 }
 256                 else {
 257                         label_ptr = "";
 258                 }
 259
 260                 /* Show empty name since it is a required field */
 261                 fputs("<field name=\"", pdata->fh);
 262                 fputs("\" show=\"", pdata->fh);
 263                 print_escaped_xml(pdata->fh, label_ptr);
 264
 265                 fprintf(pdata->fh, "\" size=\"%d", fi->length);
 266                 fprintf(pdata->fh, "\" pos=\"%d", fi->start);
 267
 268                 fputs("\" value=\"", pdata->fh);
 269                 write_pdml_field_hex_value(pdata, fi);
 270
 271                 if (node->first_child != NULL) {
 272                         fputs("\">\n", pdata->fh);
 273                 }
 274                 else {
 275                         fputs("\"/>\n", pdata->fh);
 276                 }
 277         }
 278         /* Uninterpreted data, i.e., the "Data" protocol, is
 279          * printed as a field instead of a protocol. */
 280         else if (fi->hfinfo->id == proto_data) {
 281
 282                 fputs("<field name=\"data\" value=\"", pdata->fh);
 283
 284                 write_pdml_field_hex_value(pdata, fi);
 285
 286                 fputs("\"/>\n", pdata->fh);
 287
 288         }
 289         /* Normal protocols and fields */
 290         else {
 291                 if (fi->hfinfo->type == FT_PROTOCOL) {
 292                         fputs("<proto name=\"", pdata->fh);
 293                 }
 294                 else {
 295                         fputs("<field name=\"", pdata->fh);
 296                 }
 297                 print_escaped_xml(pdata->fh, fi->hfinfo->abbrev);
 298
 299 #if 0
 300         /* PDML spec, see:
 301          * http://analyzer.polito.it/30alpha/docs/dissectors/PDMLSpec.htm
 302          *
 303          * the show fields contains things in 'human readable' format
 304          * showname: contains only the name of the field
 305          * show: contains only the data of the field
 306          * showdtl: contains additional details of the field data
 307          * showmap: contains mappings of the field data (e.g. the hostname to an IP address)
 308          *
 309          * XXX - the showname shouldn't contain the field data itself
 310          * (like it's contained in the fi->rep->representation).
 311          * Unfortunately, we don't have the field data representation for
 312          * all fields, so this isn't currently possible */
 313                 fputs("\" showname=\"", pdata->fh);
 314                 print_escaped_xml(pdata->fh, fi->hfinfo->name);
 315 #endif
 316
 317                 if (fi->rep) {
 318                         fputs("\" showname=\"", pdata->fh);
 319                         print_escaped_xml(pdata->fh, fi->rep->representation);
 320                 }
 321                 else {
 322                         label_ptr = label_str;
 323                         proto_item_fill_label(fi, label_str);
 324                         fputs("\" showname=\"", pdata->fh);
 325                         print_escaped_xml(pdata->fh, label_ptr);
 326                 }
 327
 328                 if (PROTO_ITEM_IS_HIDDEN(node))
 329                         fprintf(pdata->fh, "\" hide=\"yes");
 330
 331                 fprintf(pdata->fh, "\" size=\"%d", fi->length);
 332                 fprintf(pdata->fh, "\" pos=\"%d", fi->start);
 333 /*              fprintf(pdata->fh, "\" id=\"%d", fi->hfinfo->id);*/
 334
 335                 /* show, value, and unmaskedvalue attributes */
 336                 switch (fi->hfinfo->type)
 337                 {
 338                 case FT_PROTOCOL:
 339                         break;
 340                 case FT_NONE:
 341                         fputs("\" show=\"\" value=\"",  pdata->fh);
 342                         break;
 343                 default:
 344                         /* XXX - this is a hack until we can just call
 345                          * fvalue_to_string_repr() for *all* FT_* types. */
 346                         dfilter_string = proto_construct_dfilter_string(fi,
 347                                         pdata->edt);
 348                         if (dfilter_string != NULL) {
 349                                 chop_len = strlen(fi->hfinfo->abbrev) + 4; /* for " == " */
 350
 351                                 /* XXX - Remove double-quotes. Again, once we
 352                                  * can call fvalue_to_string_repr(), we can
 353                                  * ask it not to produce the version for
 354                                  * display-filters, and thus, no
 355                                  * double-quotes. */
 356                                 if (dfilter_string[strlen(dfilter_string)-1] == '"') {
 357                                         dfilter_string[strlen(dfilter_string)-1] = '\0';
 358                                         chop_len++;
 359                                 }
 360
 361                                 fputs("\" show=\"", pdata->fh);
 362                                 print_escaped_xml(pdata->fh, &dfilter_string[chop_len]);
 363                         }
 364                         if (fi->length > 0) {
 365                                 fputs("\" value=\"", pdata->fh);
 366
 367                                 if (fi->hfinfo->bitmask!=0) {
 368                                         fprintf(pdata->fh, "%X", fvalue_get_integer(&fi->value));
 369                                         fputs("\" unmaskedvalue=\"", pdata->fh);
 370                                         write_pdml_field_hex_value(pdata, fi);
 371                                 }
 372                                 else {
 373                     write_pdml_field_hex_value(pdata, fi);
 374                 }
 375                         }
 376                 }
 377
 378                 if (node->first_child != NULL) {
 379                         fputs("\">\n", pdata->fh);
 380                 }
 381                 else if (fi->hfinfo->id == proto_data) {
 382                         fputs("\">\n", pdata->fh);
 383                 }
 384                 else {
 385                         fputs("\"/>\n", pdata->fh);
 386                 }
 387         }
 388
 389         /* We always print all levels for PDML. Recurse here. */
 390         if (node->first_child != NULL) {
 391                 pdata->level++;
 392                 proto_tree_children_foreach(node,
 393                                 proto_tree_write_node_pdml, pdata);
 394                 pdata->level--;
 395         }
 396
 397         if (node->first_child != NULL) {
 398                 for (i = -1; i < pdata->level; i++) {
 399                         fputs("  ", pdata->fh);
 400                 }
 401                 if (fi->hfinfo->type == FT_PROTOCOL) {
 402                         fputs("</proto>\n", pdata->fh);
 403                 }
 404                 else {
 405                         fputs("</field>\n", pdata->fh);
 406                 }
 407         }
 408 }
 409
 410 /* Print info for a 'geninfo' pseudo-protocol. This is required by
 411  * the PDML spec. The information is contained in Wireshark's 'frame' protocol,
 412  * but we produce a 'geninfo' protocol in the PDML to conform to spec.
 413  * The 'frame' protocol follows the 'geninfo' protocol in the PDML. */
 414 static void
 415 print_pdml_geninfo(proto_tree *tree, FILE *fh)
 416 {
 417         guint32 num, len, caplen;
 418         nstime_t *timestamp;
 419         GPtrArray *finfo_array;
 420         field_info *frame_finfo;
 421
 422         /* Get frame protocol's finfo. */
 423         finfo_array = proto_find_finfo(tree, proto_frame);
 424         if (g_ptr_array_len(finfo_array) < 1) {
 425                 return;
 426         }
 427         frame_finfo = finfo_array->pdata[0];
 428         g_ptr_array_free(finfo_array, FALSE);
 429
 430         /* frame.number --> geninfo.num */
 431         finfo_array = proto_find_finfo(tree, hf_frame_number);
 432         if (g_ptr_array_len(finfo_array) < 1) {
 433                 return;
 434         }
 435         num = fvalue_get_integer(&((field_info*)finfo_array->pdata[0])->value);
 436         g_ptr_array_free(finfo_array, FALSE);
 437
 438         /* frame.pkt_len --> geninfo.len */
 439         finfo_array = proto_find_finfo(tree, hf_frame_packet_len);
 440         if (g_ptr_array_len(finfo_array) < 1) {
 441                 return;
 442         }
 443         len = fvalue_get_integer(&((field_info*)finfo_array->pdata[0])->value);
 444         g_ptr_array_free(finfo_array, FALSE);
 445
 446         /* frame.cap_len --> geninfo.caplen */
 447         finfo_array = proto_find_finfo(tree, hf_frame_capture_len);
 448         if (g_ptr_array_len(finfo_array) < 1) {
 449                 return;
 450         }
 451         caplen = fvalue_get_integer(&((field_info*)finfo_array->pdata[0])->value);
 452         g_ptr_array_free(finfo_array, FALSE);
 453
 454         /* frame.time --> geninfo.timestamp */
 455         finfo_array = proto_find_finfo(tree, hf_frame_arrival_time);
 456         if (g_ptr_array_len(finfo_array) < 1) {
 457                 return;
 458         }
 459         timestamp = fvalue_get(&((field_info*)finfo_array->pdata[0])->value);
 460         g_ptr_array_free(finfo_array, FALSE);
 461
 462         /* Print geninfo start */
 463         fprintf(fh,
 464 "  <proto name=\"geninfo\" pos=\"0\" showname=\"General information\" size=\"%u\">\n",
 465                 frame_finfo->length);
 466
 467         /* Print geninfo.num */
 468         fprintf(fh,
 469 "    <field name=\"num\" pos=\"0\" show=\"%u\" showname=\"Number\" value=\"%x\" size=\"%u\"/>\n",
 470                 num, num, frame_finfo->length);
 471
 472         /* Print geninfo.len */
 473         fprintf(fh,
 474 "    <field name=\"len\" pos=\"0\" show=\"%u\" showname=\"Packet Length\" value=\"%x\" size=\"%u\"/>\n",
 475                 len, len, frame_finfo->length);
 476
 477         /* Print geninfo.caplen */
 478         fprintf(fh,
 479 "    <field name=\"caplen\" pos=\"0\" show=\"%u\" showname=\"Captured Length\" value=\"%x\" size=\"%u\"/>\n",
 480                 caplen, caplen, frame_finfo->length);
 481
 482         /* Print geninfo.timestamp */
 483         fprintf(fh,
 484 "    <field name=\"timestamp\" pos=\"0\" show=\"%s\" showname=\"Captured Time\" value=\"%d.%09d\" size=\"%u\"/>\n",
 485                 abs_time_to_str(timestamp), (int) timestamp->secs, timestamp->nsecs, frame_finfo->length);
 486
 487         /* Print geninfo end */
 488         fprintf(fh,
 489 "  </proto>\n");
 490 }
 491
 492 void
 493 write_pdml_finale(FILE *fh)
 494 {
 495         fputs("</pdml>\n", fh);
 496 }
 497
 498 void
 499 write_psml_preamble(FILE *fh)
 500 {
 501         fputs("<?xml version=\"1.0\"?>\n", fh);
 502         fputs("<psml version=\"" PSML_VERSION "\" ", fh);
 503         fprintf(fh, "creator=\"%s/%s\">\n", PACKAGE, VERSION);
 504 }
 505
 506 void
 507 proto_tree_write_psml(epan_dissect_t *edt, FILE *fh)
 508 {
 509         gint    i;
 510
 511         /* if this is the first packet, we have to create the PSML structure output */
 512         if(edt->pi.fd->num == 1) {
 513             fprintf(fh, "<structure>\n");
 514
 515             for(i=0; i < edt->pi.cinfo->num_cols; i++) {
 516                 fprintf(fh, "<section>");
 517                 print_escaped_xml(fh, edt->pi.cinfo->col_title[i]);
 518                 fprintf(fh, "</section>\n");
 519             }
 520
 521             fprintf(fh, "</structure>\n\n");
 522         }
 523
 524         fprintf(fh, "<packet>\n");
 525
 526         for(i=0; i < edt->pi.cinfo->num_cols; i++) {
 527             fprintf(fh, "<section>");
 528             print_escaped_xml(fh, edt->pi.cinfo->col_data[i]);
 529             fprintf(fh, "</section>\n");
 530         }
 531
 532         fprintf(fh, "</packet>\n\n");
 533 }
 534
 535 void
 536 write_psml_finale(FILE *fh)
 537 {
 538         fputs("</psml>\n", fh);
 539 }
 540
 541 void
 542 write_csv_preamble(FILE *fh _U_)
 543 {
 544
 545 }
 546
 547 void
 548 proto_tree_write_csv(epan_dissect_t *edt, FILE *fh)
 549 {
 550         gint    i;
 551
 552         /* if this is the first packet, we have to write the CSV header */
 553         if(edt->pi.fd->num == 1) {
 554             for(i=0; i < edt->pi.cinfo->num_cols - 1; i++)
 555                 fprintf(fh, "\"%s\",", edt->pi.cinfo->col_title[i]);
 556
 557             fprintf(fh, "\"%s\"\n", edt->pi.cinfo->col_title[i]);
 558         }
 559
 560         for(i=0; i < edt->pi.cinfo->num_cols - 1; i++)
 561             fprintf(fh, "\"%s\",", edt->pi.cinfo->col_data[i]);
 562
 563         fprintf(fh, "\"%s\"\n", edt->pi.cinfo->col_data[i]);
 564 }
 565
 566 void
 567 write_csv_finale(FILE *fh _U_)
 568 {
 569
 570 }
 571
 572 /*
 573  * Find the data source for a specified field, and return a pointer
 574  * to the data in it. Returns NULL if the data is out of bounds.
 575  */
 576 static const guint8 *
 577 get_field_data(GSList *src_list, field_info *fi)
 578 {
 579         GSList *src_le;
 580         data_source *src;
 581         tvbuff_t *src_tvb;
 582         gint length, tvbuff_length;
 583
 584         for (src_le = src_list; src_le != NULL; src_le = src_le->next) {
 585                 src = src_le->data;
 586                 src_tvb = src->tvb;
 587                 if (fi->ds_tvb == src_tvb) {
 588                         /*
 589                          * Found it.
 590                          *
 591                          * XXX - a field can have a length that runs past
 592                          * the end of the tvbuff.  Ideally, that should
 593                          * be fixed when adding an item to the protocol
 594                          * tree, but checking the length when doing
 595                          * that could be expensive.  Until we fix that,
 596                          * we'll do the check here.
 597                          */
 598                         tvbuff_length = tvb_length_remaining(src_tvb,
 599                             fi->start);
 600                         if (tvbuff_length < 0) {
 601                                 return NULL;
 602                         }
 603                         length = fi->length;
 604                         if (length > tvbuff_length)
 605                                 length = tvbuff_length;
 606                         return tvb_get_ptr(src_tvb, fi->start, length);
 607                 }
 608         }
 609         g_assert_not_reached();
 610         return NULL;    /* not found */
 611 }
 612
 613 /* Print a string, escaping out certain characters that need to
 614  * escaped out for XML. */
 615 static void
 616 print_escaped_xml(FILE *fh, const char *unescaped_string)
 617 {
 618         const unsigned char *p;
 619
 620         for (p = unescaped_string; *p != '\0'; p++) {
 621                 switch (*p) {
 622                         case '&':
 623                                 fputs("&amp;", fh);
 624                                 break;
 625                         case '<':
 626                                 fputs("&lt;", fh);
 627                                 break;
 628                         case '>':
 629                                 fputs("&gt;", fh);
 630                                 break;
 631                         case '"':
 632                                 fputs("&quot;", fh);
 633                                 break;
 634                         case '\'':
 635                                 fputs("&apos;", fh);
 636                                 break;
 637                         default:
 638                                 fputc(*p, fh);
 639                 }
 640         }
 641 }
 642
 643 static void
 644 write_pdml_field_hex_value(write_pdml_data *pdata, field_info *fi)
 645 {
 646         int i;
 647         const guint8 *pd;
 648
 649         if (fi->length > tvb_length_remaining(fi->ds_tvb, fi->start)) {
 650                 fprintf(pdata->fh, "field length invalid!");
 651                 return;
 652         }
 653
 654         /* Find the data for this field. */
 655         pd = get_field_data(pdata->src_list, fi);
 656
 657         if (pd) {
 658                 /* Print a simple hex dump */
 659                 for (i = 0 ; i < fi->length; i++) {
 660                         fprintf(pdata->fh, "%02x", pd[i]);
 661                 }
 662         }
 663 }
 664
 665 gboolean
 666 print_hex_data(print_stream_t *stream, epan_dissect_t *edt)
 667 {
 668         gboolean multiple_sources;
 669         GSList *src_le;
 670         data_source *src;
 671         tvbuff_t *tvb;
 672         char *name;
 673         char *line;
 674         const guchar *cp;
 675         guint length;
 676
 677         /*
 678          * Set "multiple_sources" iff this frame has more than one
 679          * data source; if it does, we need to print the name of
 680          * the data source before printing the data from the
 681          * data source.
 682          */
 683         multiple_sources = (edt->pi.data_src->next != NULL);
 684
 685         for (src_le = edt->pi.data_src; src_le != NULL;
 686             src_le = src_le->next) {
 687                 src = src_le->data;
 688                 tvb = src->tvb;
 689                 if (multiple_sources) {
 690                         name = src->name;
 691                         print_line(stream, 0, "");
 692                         line = g_malloc(strlen(name) + 2);      /* <name>:\0 */
 693                         strcpy(line, name);
 694                         strcat(line, ":");
 695                         print_line(stream, 0, line);
 696                         g_free(line);
 697                 }
 698                 length = tvb_length(tvb);
 699                 if (length == 0)
 700                     return TRUE;
 701                 cp = tvb_get_ptr(tvb, 0, length);
 702                 if (!print_hex_data_buffer(stream, cp, length,
 703                     edt->pi.fd->flags.encoding))
 704                         return FALSE;
 705         }
 706         return TRUE;
 707 }
 708
 709 /*
 710  * This routine is based on a routine created by Dan Lasley
 711  * <DLASLEY@PROMUS.com>.
 712  *
 713  * It was modified for Wireshark by Gilbert Ramirez and others.
 714  */
 715
 716 #define MAX_OFFSET_LEN  8       /* max length of hex offset of bytes */
 717 #define BYTES_PER_LINE  16      /* max byte values printed on a line */
 718 #define HEX_DUMP_LEN    (BYTES_PER_LINE*3)
 719                                 /* max number of characters hex dump takes -
 720                                    2 digits plus trailing blank */
 721 #define DATA_DUMP_LEN   (HEX_DUMP_LEN + 2 + BYTES_PER_LINE)
 722                                 /* number of characters those bytes take;
 723                                    3 characters per byte of hex dump,
 724                                    2 blanks separating hex from ASCII,
 725                                    1 character per byte of ASCII dump */
 726 #define MAX_LINE_LEN    (MAX_OFFSET_LEN + 2 + DATA_DUMP_LEN)
 727                                 /* number of characters per line;
 728                                    offset, 2 blanks separating offset
 729                                    from data dump, data dump */
 730
 731 static gboolean
 732 print_hex_data_buffer(print_stream_t *stream, const guchar *cp,
 733     guint length, char_enc encoding)
 734 {
 735         register unsigned int ad, i, j, k, l;
 736         guchar c;
 737         guchar line[MAX_LINE_LEN + 1];
 738         unsigned int use_digits;
 739         static guchar binhex[16] = {
 740                 '0', '1', '2', '3', '4', '5', '6', '7',
 741                 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 742
 743         if (!print_line(stream, 0, ""))
 744                 return FALSE;
 745
 746         /*
 747          * How many of the leading digits of the offset will we supply?
 748          * We always supply at least 4 digits, but if the maximum offset
 749          * won't fit in 4 digits, we use as many digits as will be needed.
 750          */
 751         if (((length - 1) & 0xF0000000) != 0)
 752                 use_digits = 8; /* need all 8 digits */
 753         else if (((length - 1) & 0x0F000000) != 0)
 754                 use_digits = 7; /* need 7 digits */
 755         else if (((length - 1) & 0x00F00000) != 0)
 756                 use_digits = 6; /* need 6 digits */
 757         else if (((length - 1) & 0x000F0000) != 0)
 758                 use_digits = 5; /* need 5 digits */
 759         else
 760                 use_digits = 4; /* we'll supply 4 digits */
 761
 762         ad = 0;
 763         i = 0;
 764         j = 0;
 765         k = 0;
 766         while (i < length) {
 767                 if ((i & 15) == 0) {
 768                         /*
 769                          * Start of a new line.
 770                          */
 771                         j = 0;
 772                         k = 0;
 773                         l = use_digits;
 774                         do {
 775                                 l--;
 776                                 c = (ad >> (l*4)) & 0xF;
 777                                 line[j++] = binhex[c];
 778                         } while (l != 0);
 779                         line[j++] = ' ';
 780                         line[j++] = ' ';
 781                         memset(line+j, ' ', DATA_DUMP_LEN);
 782
 783                         /*
 784                          * Offset in line of ASCII dump.
 785                          */
 786                         k = j + HEX_DUMP_LEN + 2;
 787                 }
 788                 c = *cp++;
 789                 line[j++] = binhex[c>>4];
 790                 line[j++] = binhex[c&0xf];
 791                 j++;
 792                 if (encoding == CHAR_EBCDIC) {
 793                         c = EBCDIC_to_ASCII1(c);
 794                 }
 795                 line[k++] = c >= ' ' && c < 0x7f ? c : '.';
 796                 i++;
 797                 if ((i & 15) == 0 || i == length) {
 798                         /*
 799                          * We'll be starting a new line, or
 800                          * we're finished printing this buffer;
 801                          * dump out the line we've constructed,
 802                          * and advance the offset.
 803                          */
 804                         line[k] = '\0';
 805                         if (!print_line(stream, 0, line))
 806                                 return FALSE;
 807                         ad += 16;
 808                 }
 809         }
 810         return TRUE;
 811 }
 812
 813 static
 814 void ps_clean_string(unsigned char *out, const unsigned char *in,
 815                         int outbuf_size)
 816 {
 817         int rd, wr;
 818         char c;
 819
 820         for (rd = 0, wr = 0 ; wr < outbuf_size; rd++, wr++ ) {
 821                 c = in[rd];
 822                 switch (c) {
 823                         case '(':
 824                         case ')':
 825                         case '\\':
 826                                 out[wr] = '\\';
 827                                 out[++wr] = c;
 828                                 break;
 829
 830                         default:
 831                                 out[wr] = c;
 832                                 break;
 833                 }
 834
 835                 if (c == 0) {
 836                         break;
 837                 }
 838         }
 839 }
 840
 841 /* Some formats need stuff at the beginning of the output */
 842 gboolean
 843 print_preamble(print_stream_t *self, gchar *filename)
 844 {
 845         return (self->ops->print_preamble)(self, filename);
 846 }
 847
 848 gboolean
 849 print_line(print_stream_t *self, int indent, const char *line)
 850 {
 851         return (self->ops->print_line)(self, indent, line);
 852 }
 853
 854 /* Insert bookmark */
 855 gboolean
 856 print_bookmark(print_stream_t *self, const gchar *name, const gchar *title)
 857 {
 858         return (self->ops->print_bookmark)(self, name, title);
 859 }
 860
 861 gboolean
 862 new_page(print_stream_t *self)
 863 {
 864         return (self->ops->new_page)(self);
 865 }
 866
 867 /* Some formats need stuff at the end of the output */
 868 gboolean
 869 print_finale(print_stream_t *self)
 870 {
 871         return (self->ops->print_finale)(self);
 872 }
 873
 874 gboolean
 875 destroy_print_stream(print_stream_t *self)
 876 {
 877         return (self->ops->destroy)(self);
 878 }
 879
 880 typedef struct {
 881         int to_file;
 882         FILE *fh;
 883 } output_text;
 884
 885 static gboolean
 886 print_preamble_text(print_stream_t *self _U_, gchar *filename _U_)
 887 {
 888         /* do nothing */
 889         return TRUE;    /* always succeeds */
 890 }
 891
 892 static gboolean
 893 print_line_text(print_stream_t *self, int indent, const char *line)
 894 {
 895         output_text *output = self->data;
 896         char space[MAX_INDENT+1];
 897         int i;
 898         int num_spaces;
 899
 900         /* Prepare the tabs for printing, depending on tree level */
 901         num_spaces = indent * 4;
 902         if (num_spaces > MAX_INDENT) {
 903                 num_spaces = MAX_INDENT;
 904         }
 905         for (i = 0; i < num_spaces; i++) {
 906                 space[i] = ' ';
 907         }
 908         /* The string is NUL-terminated */
 909         space[num_spaces] = '\0';
 910
 911         fputs(space, output->fh);
 912         fputs(line, output->fh);
 913         putc('\n', output->fh);
 914         return !ferror(output->fh);
 915 }
 916
 917 static gboolean
 918 print_bookmark_text(print_stream_t *self _U_, const gchar *name _U_,
 919     const gchar *title _U_)
 920 {
 921         /* do nothing */
 922         return TRUE;
 923 }
 924
 925 static gboolean
 926 new_page_text(print_stream_t *self)
 927 {
 928         output_text *output = self->data;
 929
 930         fputs("\f", output->fh);
 931         return !ferror(output->fh);
 932 }
 933
 934 static gboolean
 935 print_finale_text(print_stream_t *self _U_)
 936 {
 937         /* do nothing */
 938         return TRUE;    /* always succeeds */
 939 }
 940
 941 static gboolean
 942 destroy_text(print_stream_t *self)
 943 {
 944         output_text *output = self->data;
 945         gboolean ret;
 946
 947         ret = close_print_dest(output->to_file, output->fh);
 948         g_free(output);
 949         g_free(self);
 950         return ret;
 951 }
 952
 953 static const print_stream_ops_t print_text_ops = {
 954         print_preamble_text,
 955         print_line_text,
 956         print_bookmark_text,
 957         new_page_text,
 958         print_finale_text,
 959         destroy_text
 960 };
 961
 962 print_stream_t *
 963 print_stream_text_new(int to_file, const char *dest)
 964 {
 965         FILE *fh;
 966         print_stream_t *stream;
 967         output_text *output;
 968
 969         fh = open_print_dest(to_file, dest);
 970         if (fh == NULL)
 971                 return NULL;
 972
 973         output = g_malloc(sizeof *output);
 974         output->to_file = to_file;
 975         output->fh = fh;
 976         stream = g_malloc(sizeof (print_stream_t));
 977         stream->ops = &print_text_ops;
 978         stream->data = output;
 979
 980         return stream;
 981 }
 982
 983 print_stream_t *
 984 print_stream_text_stdio_new(FILE *fh)
 985 {
 986         print_stream_t *stream;
 987         output_text *output;
 988
 989         output = g_malloc(sizeof *output);
 990         output->to_file = TRUE;
 991         output->fh = fh;
 992         stream = g_malloc(sizeof (print_stream_t));
 993         stream->ops = &print_text_ops;
 994         stream->data = output;
 995
 996         return stream;
 997 }
 998
 999 typedef struct {
1000         int to_file;
1001         FILE *fh;
1002 } output_ps;
1003
1004 static gboolean
1005 print_preamble_ps(print_stream_t *self, gchar *filename)
1006 {
1007         output_ps *output = self->data;
1008         char            psbuffer[MAX_PS_LINE_LENGTH]; /* static sized buffer! */
1009
1010         print_ps_preamble(output->fh);
1011
1012         fputs("%% Set the font to 10 point\n", output->fh);
1013         fputs("/Courier findfont 10 scalefont setfont\n", output->fh);
1014         fputs("\n", output->fh);
1015         fputs("%% the page title\n", output->fh);
1016         ps_clean_string(psbuffer, filename, MAX_PS_LINE_LENGTH);
1017         fprintf(output->fh, "/eth_pagetitle (%s - Wireshark) def\n", psbuffer);
1018         fputs("\n", output->fh);
1019         return !ferror(output->fh);
1020 }
1021
1022 static gboolean
1023 print_line_ps(print_stream_t *self, int indent, const char *line)
1024 {
1025         output_ps *output = self->data;
1026         char            psbuffer[MAX_PS_LINE_LENGTH]; /* static sized buffer! */
1027
1028         ps_clean_string(psbuffer, line, MAX_PS_LINE_LENGTH);
1029         fprintf(output->fh, "%d (%s) putline\n", indent, psbuffer);
1030         return !ferror(output->fh);
1031 }
1032
1033 static gboolean
1034 print_bookmark_ps(print_stream_t *self, const gchar *name, const gchar *title)
1035 {
1036         output_ps *output = self->data;
1037         char            psbuffer[MAX_PS_LINE_LENGTH]; /* static sized buffer! */
1038
1039         /*
1040          * See the Adobe "pdfmark reference":
1041          *
1042          *      http://partners.adobe.com/asn/acrobat/docs/pdfmark.pdf
1043          *
1044          * The pdfmark stuff tells code that turns PostScript into PDF
1045          * things that it should do.
1046          *
1047          * The /OUT stuff creates a bookmark that goes to the
1048          * destination with "name" as the name and "title" as the title.
1049          *
1050          * The "/DEST" creates the destination.
1051          */
1052         ps_clean_string(psbuffer, title, MAX_PS_LINE_LENGTH);
1053         fprintf(output->fh, "[/Dest /%s /Title (%s)   /OUT pdfmark\n", name,
1054             psbuffer);
1055         fputs("[/View [/XYZ -4 currentpoint matrix currentmatrix matrix defaultmatrix\n",
1056             output->fh);
1057         fputs("matrix invertmatrix matrix concatmatrix transform exch pop 20 add null]\n",
1058             output->fh);
1059         fprintf(output->fh, "/Dest /%s /DEST pdfmark\n", name);
1060         return !ferror(output->fh);
1061 }
1062
1063 static gboolean
1064 new_page_ps(print_stream_t *self)
1065 {
1066         output_ps *output = self->data;
1067
1068         fputs("formfeed\n", output->fh);
1069         return !ferror(output->fh);
1070 }
1071
1072 static gboolean
1073 print_finale_ps(print_stream_t *self)
1074 {
1075         output_ps *output = self->data;
1076
1077         print_ps_finale(output->fh);
1078         return !ferror(output->fh);
1079 }
1080
1081 static gboolean
1082 destroy_ps(print_stream_t *self)
1083 {
1084         output_ps *output = self->data;
1085         gboolean ret;
1086
1087         ret = close_print_dest(output->to_file, output->fh);
1088         g_free(output);
1089         g_free(self);
1090         return ret;
1091 }
1092
1093 static const print_stream_ops_t print_ps_ops = {
1094         print_preamble_ps,
1095         print_line_ps,
1096         print_bookmark_ps,
1097         new_page_ps,
1098         print_finale_ps,
1099         destroy_ps
1100 };
1101
1102 print_stream_t *
1103 print_stream_ps_new(int to_file, const char *dest)
1104 {
1105         FILE *fh;
1106         print_stream_t *stream;
1107         output_ps *output;
1108
1109         fh = open_print_dest(to_file, dest);
1110         if (fh == NULL)
1111                 return NULL;
1112
1113         output = g_malloc(sizeof *output);
1114         output->to_file = to_file;
1115         output->fh = fh;
1116         stream = g_malloc(sizeof (print_stream_t));
1117         stream->ops = &print_ps_ops;
1118         stream->data = output;
1119
1120         return stream;
1121 }
1122
1123 print_stream_t *
1124 print_stream_ps_stdio_new(FILE *fh)
1125 {
1126         print_stream_t *stream;
1127         output_ps *output;
1128
1129         output = g_malloc(sizeof *output);
1130         output->to_file = TRUE;
1131         output->fh = fh;
1132         stream = g_malloc(sizeof (print_stream_t));
1133         stream->ops = &print_ps_ops;
1134         stream->data = output;
1135
1136         return stream;
1137 }