wiretap/iseries.c

   1 /* iseries.c
   2  *
   3  * $Id$
   4  *
   5  * Wiretap Library
   6  * Copyright (c) 2005 by Martin Warnes <Martin_Warnes@Stercomm.com>
   7  *
   8  * Based on toshiba.c and vms.c
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 /*
  26  * This module will read the contents of the iSeries (OS/400) Communication trace
  27  * Both ASCII & Unicode formatted traces are supported.
  28  *
  29  * iSeries Comms traces consist of a header page and a subsequent number of packet records
  30  *
  31  * The header page contains details on the options set during running of the trace,
  32  * currently the following options are a requirement for this module:
  33  *
  34  * 1. Object protocol = ETHERNET (Default)
  35  * 2. ASCII or UNICODE file formats.
  36  *
  37  * The above can be acheived by passing option ASCII(*YES) with the trace command
  38  *
  39  */
  40
  41 /* iSeries header page
  42
  43  COMMUNICATIONS TRACE       Title: OS400 - OS400 trace               10/28/05  11:44:50                           Page:       1
  44    Trace Description  . . . . . :   OS400 - OS400 trace
  45    Configuration object . . . . :   ETH0
  46    Type . . . . . . . . . . . . :   1            1=Line, 2=Network Interface
  47                                                  3=Network server
  48    Object protocol  . . . . . . :   ETHERNET
  49    Start date/Time  . . . . . . :   10/28/05  11:43:00.341
  50    End date/Time  . . . . . . . :   10/28/05  11:44:22.148
  51    Bytes collected  . . . . . . :   11999
  52    Buffer size  . . . . . . . . :   2048         kilobytes
  53    Data direction . . . . . . . :   3            1=Sent, 2=Received, 3=Both
  54    Stop on buffer full  . . . . :   Y            Y=Yes, N=No
  55    Number of bytes to trace
  56      Beginning bytes  . . . . . :   *MAX         Value, *CALC, *MAX
  57      Ending bytes   . . . . . . :   *CALC        Value, *CALC
  58    Controller name  . . . . . . :   *ALL         *ALL, name
  59    Data representation  . . . . :   1            1=ASCII, 2=EBCDIC, 3=*CALC
  60    Format SNA data only . . . . :   N            Y=Yes, N=No
  61    Format RR, RNR commands  . . :   N            Y=Yes, N=No
  62    Format TCP/IP data only  . . :   Y            Y=Yes, N=No
  63      IP address . . . . . . . . :   *ALL             *ALL, address
  64      IP address . . . . . . . . :   *ALL             *ALL, address
  65      IP port  . . . . . . . . . :   *ALL             *ALL, IP port
  66    Format UI data only  . . . . :   N            Y=Yes, N=No
  67    Select Ethernet data . . . . :   3            1=802.3, 2=ETHV2, 3=Both
  68    Format Broadcast data  . . . :   Y            Y=Yes, N=No
  69 */
  70
  71 /* iSeries formatted packet records consist of a header line identifying the packet number,direction,size,
  72  * timestamp,source/destination MAC addresses and packet type.
  73  *
  74  * Thereafter there will be a formated display of the IP and TCP headers as well as a hex string dump
  75  * of the headers themselves displayed in the the "IP Header" and "TCP header" fields.
  76  *
  77  * If the packet contains data this is displayed as 4 groups of 16 hex digits followed by an ASCII
  78  * representaion of the data line.
  79  *
  80  * Information from the header line, IP header, TCP header and if available data lines are extracted
  81  * by the module for displaying.
  82  *
  83  *
  84  Record       Data    Record           Controller  Destination   Source        Frame
  85  Number  S/R  Length  Timer            Name        MAC Address   MAC Address   Format
  86  ------  ---  ------  ---------------  ----------  ------------  ------------  ------
  87       8   S      145  11:43:59.82956               0006299C14AE  0006299C14FE   ETHV2   Type: 0800
  88                       Frame Type :  IP          DSCP: 0   ECN: 00-NECT  Length:   145   Protocol: TCP         Datagram ID: 388B
  89                                     Src Addr: 10.20.144.150       Dest Addr: 10.20.144.151       Fragment Flags: DON'T,LAST
  90                       IP Header  :  45000091388B40004006CC860A1490960A149097
  91                       IP Options :  NONE
  92                       TCP  . . . :  Src Port:  6006,Unassigned    Dest Port: 35366,Unassigned
  93                                     SEQ Number:  2666470699 ('9EEF1D2B'X)  ACK Number: 2142147535 ('7FAE93CF'X)
  94                                     Code Bits: ACK PSH                  Window: 32648  TCP Option: NO OP
  95                       TCP Header :  17768A269EEF1D2B7FAE93CF80187F885B5600000101080A0517E0F805166DE0
  96          Data . . . . . :  5443503200020010 0000004980000000  B800000080470103 01001E0000002000   *TCP2.......I*...*...*G........ .*
  97                            002F010080000004 0300800700C00600  4002008000000304 00800000060FB067   *./..*.....*..*..@..*.....*....*G*
  98                            FC276228786B3EB0 EF34F5F1D27EF8DF  20926820E7B322AA 739F1FB20D         **'B(XK>**4***.** *H **"*S*.*.   *
  99 */
 100
 101 /* iSeries unformatted packet record consist of the same header record as the formatted trace but all
 102  * other records are simply unformatted data containing IP, TCP and packet data combined.
 103  *
 104  Record       Data    Record           Controller  Destination   Source        Frame            Number  Number    Poll/
 105  Number  S/R  Length  Timer            Name        MAC Address   MAC Address   Format  Command  Sent    Received  Final  DSAP  SSAP
 106  ------  ---  ------  ---------------  ----------  ------------  ------------  ------  -------  ------  --------  -----  ----  ----
 107       1   R       64  12:19:29.97108               000629ECF48E  0006D78E23C2   ETHV2   Type: 0800
 108          Data . . . . . :  4500003C27954000 3A06CE3D9797440F  0A5964EAC4F50554 58C9915500000000   *E..<'*@.:.*=**D..YD***.TX**U....*
 109                            A00216D06A200000 020405B40402080A  1104B6C000000000 010303000B443BF1   **..*J .....*......**.........D;**
 110 */
 111
 112 #ifdef HAVE_CONFIG_H
 113 #include "config.h"
 114 #endif
 115 #include "wtap-int.h"
 116 #include "buffer.h"
 117 #include "iseries.h"
 118 #include "file_wrappers.h"
 119
 120 #include <stdio.h>
 121 #include <stdlib.h>
 122 #include <string.h>
 123 #include <ctype.h>
 124 #include <errno.h>
 125
 126 #include <wsutil/str_util.h>
 127
 128 #define ISERIES_HDR_MAGIC_STR   " COMMUNICATIONS TRACE"
 129 #define ISERIES_HDR_MAGIC_LEN   21
 130 #define ISERIES_PKT_MAGIC_STR   "ETHV2"
 131 #define ISERIES_PKT_MAGIC_LEN   5
 132 #define ISERIES_LINE_LENGTH     270
 133 #define ISERIES_HDR_LINES_TO_CHECK  50
 134 #define ISERIES_PKT_LINES_TO_CHECK  4
 135 #define ISERIES_MAX_PACKET_LEN  16384
 136 #define ISERIES_MAX_TRACE_LEN   99999999
 137 #define ISERIES_PKT_ALLOC_SIZE (cap_len*2)+1
 138 #define ISERIES_FORMAT_ASCII    1
 139 #define ISERIES_FORMAT_UNICODE  2
 140
 141 static gboolean iseries_read (wtap * wth, int *err, gchar ** err_info,
 142                               gint64 *data_offset);
 143 static gboolean iseries_seek_read (wtap * wth, gint64 seek_off,
 144                                    union wtap_pseudo_header *pseudo_header,
 145                                    guint8 * pd, int len, int *err,
 146                                    gchar ** err_info);
 147 static gboolean iseries_check_file_type (wtap * wth, int *err, int format);
 148 static gint64 iseries_seek_next_packet (wtap * wth, int *err);
 149 static int iseries_parse_packet (wtap * wth, FILE_T fh,
 150                                  union wtap_pseudo_header *pseudo_header,
 151                                  guint8 * pd, int *err, gchar ** err_info);
 152 static int iseries_UNICODE_to_ASCII (guint8 * buf, guint bytes);
 153 static gboolean iseries_parse_hex_string (const char * ascii, guint8 * buf,
 154                                           int len);
 155
 156 int
 157 iseries_open (wtap * wth, int *err, gchar ** err_info _U_)
 158 {
 159   int bytes_read;
 160   char magic[ISERIES_HDR_MAGIC_LEN];
 161   /* UNICODE identification */
 162   char unicodemagic[ISERIES_HDR_MAGIC_LEN] =
 163     { '\xFF', '\xFE', '\x20', '\x00', '\x43', '\x00', '\x4F', '\x00', '\x4D',
 164     '\x00', '\x4D', '\x00', '\x55', '\x00', '\x4E', '\x00', '\x49', '\x00',
 165     '\x43', '\x00', '\x41'
 166   };
 167
 168   /*
 169    * Check that file starts with a valid iSeries COMMS TRACE header
 170    */
 171   errno = WTAP_ERR_CANT_READ;
 172   bytes_read = file_read (&magic, 1, sizeof magic, wth->fh);
 173   if (bytes_read != sizeof magic)
 174     {
 175       *err = file_error (wth->fh);
 176       if (*err != 0)
 177         return -1;
 178       return 0;
 179     }
 180
 181   /* Check if this is an ASCII formatted file */
 182   if (memcmp (magic, ISERIES_HDR_MAGIC_STR, ISERIES_HDR_MAGIC_LEN) == 0)
 183     {
 184       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 185         {
 186           return 0;
 187         }
 188       /*
 189        * Do some basic sanity checking to ensure we can handle the
 190        * contents of this trace
 191        */
 192       if (!iseries_check_file_type (wth, err, ISERIES_FORMAT_ASCII))
 193         {
 194           if (*err == 0)
 195             return 0;
 196           else
 197             return -1;
 198         }
 199       wth->data_offset = 0;
 200       wth->file_encap = WTAP_ENCAP_ETHERNET;
 201       wth->file_type = WTAP_FILE_ISERIES;
 202       wth->snapshot_length = 0;
 203       wth->subtype_read = iseries_read;
 204       wth->subtype_seek_read = iseries_seek_read;
 205       wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 206       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 207         {
 208           return 0;
 209         }
 210       return 1;
 211     }
 212
 213   /* Check if this is a UNICODE formatted file */
 214   if (memcmp (magic, unicodemagic, ISERIES_HDR_MAGIC_LEN) == 0)
 215     {
 216       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 217         {
 218           return 0;
 219         }
 220       /*
 221        * Do some basic sanity checking to ensure we can handle the
 222        * contents of this trace
 223        */
 224       if (!iseries_check_file_type (wth, err, ISERIES_FORMAT_UNICODE))
 225         {
 226           if (*err == 0)
 227             return 0;
 228           else
 229             return -1;
 230         }
 231       wth->data_offset = 0;
 232       wth->file_encap = WTAP_ENCAP_ETHERNET;
 233       wth->file_type = WTAP_FILE_ISERIES_UNICODE;
 234       wth->snapshot_length = 0;
 235       wth->subtype_read = iseries_read;
 236       wth->subtype_seek_read = iseries_seek_read;
 237       wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 238       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 239         {
 240           return 0;
 241         }
 242       return 1;
 243     }
 244
 245   /* Neither ASCII or UNICODE so not supported */
 246   return 0;
 247 }
 248
 249 /*
 250  * Do some basic sanity checking to ensure we can handle the
 251  * contents of this trace by checking the header page for
 252  * requisit requirements and additional information.
 253  */
 254 static gboolean
 255 iseries_check_file_type (wtap * wth, int *err, int format)
 256 {
 257   guint line;
 258   int num_items_scanned;
 259   char buf[ISERIES_LINE_LENGTH], protocol[9], tcpformat[2];
 260   char *sdate;
 261
 262   /* Save trace format for passing between packets */
 263   sdate = g_malloc (10);
 264   wth->capture.iseries = g_malloc (sizeof (iseries_t));
 265   wth->capture.iseries->sdate = NULL;
 266   wth->capture.iseries->format = format;
 267   wth->capture.iseries->tcp_formatted = FALSE;
 268
 269   for (line = 0; line < ISERIES_HDR_LINES_TO_CHECK; line++)
 270     {
 271       if (file_gets (buf, ISERIES_LINE_LENGTH, wth->fh) != NULL)
 272         {
 273           /*
 274            * Check that we are dealing with an ETHERNET trace
 275            */
 276           if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 277             {
 278              iseries_UNICODE_to_ASCII ((guint8 *)buf, ISERIES_LINE_LENGTH);
 279             }
 280           ascii_strup_inplace(buf);
 281           num_items_scanned = sscanf (buf,
 282                                       "   OBJECT PROTOCOL  . . . . . . :  %8s",
 283                                       protocol);
 284           if (num_items_scanned == 1)
 285             {
 286               if (memcmp (protocol, "ETHERNET", 8) != 0)
 287                 return FALSE;
 288             }
 289
 290           /*
 291            * Determine if the data has been formatted or not
 292            */
 293           num_items_scanned = sscanf (buf,
 294                                       "   FORMAT TCP/IP DATA ONLY  . . :  %1s",
 295                                       tcpformat);
 296           if (num_items_scanned == 1)
 297             {
 298               if (strncmp (tcpformat, "Y", 1) == 0)
 299                 {
 300                   wth->capture.iseries->tcp_formatted = TRUE;
 301                 }
 302               else
 303                 {
 304                   wth->capture.iseries->tcp_formatted = FALSE;
 305                 }
 306             }
 307
 308           /*
 309            * The header is the only place where the date part of the timestamp is held, so
 310            * extract it here and store for all packets to access
 311            */
 312           num_items_scanned = sscanf (buf,
 313                                       "   START DATE/TIME  . . . . . . :  %8s",
 314                                       sdate);
 315           if (num_items_scanned == 1)
 316             {
 317               wth->capture.iseries->sdate = sdate;
 318             }
 319
 320         }
 321       else
 322         {
 323           /* EOF or error. */
 324           if (file_eof (wth->fh))
 325             *err = 0;
 326           else
 327             *err = file_error (wth->fh);
 328           return FALSE;
 329         }
 330     }
 331   *err = 0;
 332   return TRUE;
 333 }
 334
 335 /*
 336  * Find the next packet and parse it; called from wtap_read().
 337  */
 338 static gboolean
 339 iseries_read (wtap * wth, int *err, gchar ** err_info, gint64 *data_offset)
 340 {
 341   gint64 offset;
 342   int pkt_len;
 343
 344   /*
 345    * Locate the next packet
 346    */
 347   offset = iseries_seek_next_packet (wth, err);
 348   if (offset < 1)
 349     return FALSE;
 350
 351   /*
 352    * Parse the packet and extract the various fields
 353    */
 354   pkt_len =
 355     iseries_parse_packet (wth, wth->fh, &wth->pseudo_header, NULL, err,
 356                           err_info);
 357   if (pkt_len == -1)
 358     return FALSE;
 359
 360   wth->data_offset = offset;
 361   *data_offset = offset;
 362   return TRUE;
 363 }
 364
 365 /*
 366  * Seeks to the beginning of the next packet, and returns the
 367  * byte offset.  Returns -1 on failure, and sets "*err" to the error.
 368  */
 369 static gint64
 370 iseries_seek_next_packet (wtap * wth, int *err)
 371 {
 372   char buf[ISERIES_LINE_LENGTH];
 373   int line;
 374   gint64 cur_off;
 375   long buflen;
 376
 377   /*
 378    * Seeks to the beginning of the next packet, and returns the
 379    * byte offset.  Returns -1 on failure, and sets "*err" to the error.
 380    */
 381   for (line = 0; line < ISERIES_MAX_TRACE_LEN; line++)
 382     {
 383       if (file_gets (buf, ISERIES_LINE_LENGTH, wth->fh) != NULL)
 384         {
 385
 386           /* Convert UNICODE to ASCII if required and determine    */
 387           /* the number of bytes to rewind to beginning of record. */
 388           if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 389             {
 390               /* buflen is #bytes to 1st 0x0A */
 391              buflen = iseries_UNICODE_to_ASCII ((guint8 *)buf, ISERIES_LINE_LENGTH);
 392             }
 393           else
 394             {
 395               /* Else buflen is just length of the ASCII string */
 396               buflen = strlen (buf);
 397             }
 398           /* If packet header found return the offset */
 399           if (strncmp (buf + 80, ISERIES_PKT_MAGIC_STR, ISERIES_PKT_MAGIC_LEN)
 400               == 0)
 401             {
 402               /* Rewind to beginning of line */
 403               cur_off = file_tell (wth->fh);
 404               if (cur_off == -1)
 405                 {
 406                   *err = file_error (wth->fh);
 407                   return -1;
 408                 }
 409               if (file_seek (wth->fh, cur_off - buflen, SEEK_SET, err) == -1)
 410                 {
 411                   return -1;
 412                 }
 413               return cur_off - buflen;
 414             }
 415         }
 416       /* Otherwise we got an error or reached EOF */
 417       else
 418         {
 419           if (file_eof (wth->fh))
 420             {
 421               *err = 0;
 422             }
 423           else
 424             {
 425               /* We (presumably) got an error (there's no equivalent to "ferror()"
 426                  in zlib, alas, so we don't have a wrapper to check for an error). */
 427               *err = file_error (wth->fh);
 428             }
 429           return -1;
 430         }
 431     }
 432
 433   return -1;
 434 }
 435
 436 /*
 437  * Read packets in random-access fashion
 438  */
 439 static gboolean
 440 iseries_seek_read (wtap * wth, gint64 seek_off,
 441                    union wtap_pseudo_header *pseudo_header, guint8 * pd,
 442                    int len, int *err, gchar ** err_info)
 443 {
 444   int pkt_len;
 445
 446   /* seek to packet location */
 447   if (file_seek (wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
 448     return FALSE;
 449
 450   /*
 451    * Parse the packet and extract the various fields
 452    */
 453   pkt_len = iseries_parse_packet (wth, wth->random_fh, pseudo_header, pd,
 454                                   err, err_info);
 455
 456   if (pkt_len != len)
 457     {
 458       if (pkt_len != -1)
 459         {
 460           *err = WTAP_ERR_BAD_RECORD;
 461           *err_info =
 462             g_strdup_printf
 463             ("iseries: requested length %d doesn't match record length %d",
 464              len, pkt_len);
 465         }
 466       return FALSE;
 467     }
 468   return TRUE;
 469 }
 470
 471 /* Parses a packet. */
 472 static int
 473 iseries_parse_packet (wtap * wth, FILE_T fh,
 474                       union wtap_pseudo_header *pseudo_header, guint8 * pd,
 475                       int *err, gchar ** err_info)
 476 {
 477   gint64 cur_off;
 478   gboolean isValid, isCurrentPacket, IPread, TCPread, isDATA;
 479   int num_items_scanned, line, pktline, buflen, i;
 480   guint32 pkt_len;
 481   int cap_len, pktnum, month, day, year, hr, min, sec, csec;
 482   char direction[2], destmac[13], srcmac[13], type[5], ipheader[41],
 483     tcpheader[81];
 484   char hex1[17], hex2[17], hex3[17], hex4[17];
 485   char data[ISERIES_LINE_LENGTH * 2];
 486   guint8 *buf;
 487   char   *asciibuf, *tcpdatabuf, *workbuf;
 488   struct tm tm;
 489
 490   /*
 491    * Check for packet headers in first 3 lines this should handle page breaks
 492    * situations and the header lines output at each page throw and ensure we
 493    * read both the captured and packet lengths.
 494    */
 495   isValid = FALSE;
 496   for (line = 1; line < ISERIES_PKT_LINES_TO_CHECK; line++)
 497     {
 498       cur_off = file_tell (fh);
 499       if (file_gets (data, ISERIES_LINE_LENGTH, fh) == NULL)
 500         {
 501           *err = file_error (fh);
 502           if (*err == 0)
 503             {
 504               *err = WTAP_ERR_SHORT_READ;
 505             }
 506           return -1;
 507         }
 508       /* Convert UNICODE data to ASCII */
 509       if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 510         {
 511          iseries_UNICODE_to_ASCII ((guint8 *)data, ISERIES_LINE_LENGTH);
 512         }
 513       /* look for packet header */
 514       for (i=0; i<8; i++) {
 515                   if (strncmp(data+i,"*",1) == 0)
 516                           g_strlcpy(data+i," ",(ISERIES_LINE_LENGTH * 2));
 517       }
 518       num_items_scanned =
 519         sscanf (data,
 520                 "%6d   %1s   %6d  %d:%d:%d.%d               %12s  %12s  ETHV2   Type: %4s",
 521                 &pktnum, direction, &cap_len, &hr, &min, &sec, &csec, destmac,
 522                 srcmac, type);
 523       if (num_items_scanned == 10)
 524         {
 525           /* OK! We found the packet header line */
 526           isValid = TRUE;
 527           /*
 528            * XXX - The Capture length returned by the iSeries trace doesn't seem to include the src/dest MAC
 529            * addresses or the packet type. So we add them here.
 530            */
 531           cap_len += 14;
 532           break;
 533         }
 534     }
 535
 536   /*
 537    * If no packet header found we exit at this point and inform the user.
 538    */
 539   if (!isValid)
 540     {
 541       *err = WTAP_ERR_BAD_RECORD;
 542       *err_info = g_strdup ("iseries: packet header isn't valid");
 543       return -1;
 544     }
 545
 546   /*
 547    * If we have Wiretap Header then populate it here
 548    *
 549    * XXX - Timer resolution on the iSeries is hardware dependant; the value for csec may be
 550    * different on other platforms though all the traces I've seen seem to show resolution
 551    * to Milliseconds (i.e HH:MM:SS.nnnnn) or Nanoseconds (i.e HH:MM:SS.nnnnnn)
 552    */
 553   if (wth->capture.iseries->sdate)
 554     {
 555       num_items_scanned =
 556         sscanf (wth->capture.iseries->sdate, "%d/%d/%d", &month, &day, &year);
 557       tm.tm_year = 100 + year;
 558       tm.tm_mon = month - 1;
 559       tm.tm_mday = day;
 560       tm.tm_hour = hr;
 561       tm.tm_min = min;
 562       tm.tm_sec = sec;
 563       tm.tm_isdst = -1;
 564       wth->phdr.ts.secs = mktime (&tm);
 565       /* Handle Millisecond precision for timer */
 566       if (csec > 99999)
 567         {
 568           wth->phdr.ts.nsecs = csec * 1000;
 569         }
 570       /* Handle Nanosecond precision for timer */
 571       else
 572         {
 573           wth->phdr.ts.nsecs = csec * 10000;
 574         }
 575     }
 576
 577     wth->phdr.caplen = cap_len;
 578     wth->phdr.pkt_encap = WTAP_ENCAP_ETHERNET;
 579     pseudo_header->eth.fcs_len = -1;
 580
 581   /*
 582    * Start Reading packet contents
 583    */
 584   isCurrentPacket = TRUE;
 585   IPread = FALSE;
 586   TCPread = FALSE;
 587   isDATA = FALSE;
 588   /*
 589    * Allocate 2 work buffers to handle concatentation of the hex data block
 590    */
 591   tcpdatabuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 592   g_snprintf (tcpdatabuf, 1, "%s", "");
 593   workbuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 594   g_snprintf (workbuf, 1, "%s", "");
 595   /* loop through packet lines and breakout when the next packet header is read */
 596   pktline = 0;
 597   while (isCurrentPacket)
 598     {
 599       pktline++;
 600       /* Read the next line */
 601       if (file_gets (data, ISERIES_LINE_LENGTH, fh) == NULL)
 602         {
 603           if (file_eof (fh))
 604             {
 605               break;
 606             }
 607           else
 608             {
 609               *err = file_error (fh);
 610               if (*err == 0)
 611                 {
 612                   *err = WTAP_ERR_SHORT_READ;
 613                 }
 614               return -1;
 615             }
 616         }
 617
 618       /* Convert UNICODE data to ASCII and determine line length */
 619       if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 620         {
 621          buflen = iseries_UNICODE_to_ASCII ((guint8 *)data, ISERIES_LINE_LENGTH);
 622         }
 623       else
 624         {
 625           /* Else bytes to rewind is just length of ASCII string */
 626           buflen = strlen (data);
 627         }
 628
 629       /* If this is a IP header hex string then set flag */
 630       num_items_scanned = sscanf (data + 22, "IP Header  : %40s", ipheader);
 631       if (num_items_scanned == 1)
 632         {
 633           IPread = TRUE;
 634         }
 635
 636       /* If this is TCP header hex string then set flag */
 637       num_items_scanned = sscanf (data + 22, "TCP Header : %80s", tcpheader);
 638       if (num_items_scanned == 1)
 639         {
 640           TCPread = TRUE;
 641         }
 642
 643       /*
 644        * If there is data in the packet handle it here.
 645        *
 646        * The data header line will have the "Data . . " identifier, subsequent lines don't
 647        */
 648       num_items_scanned =
 649         sscanf (data + 27, "%16[A-Z0-9] %16[A-Z0-9] %16[A-Z0-9] %16[A-Z0-9]",
 650                 hex1, hex2, hex3, hex4);
 651       if (num_items_scanned > 0)
 652         {
 653           isDATA = TRUE;
 654           /*
 655            * Scan the data line for data blocks, depending on the number of blocks scanned
 656            * add them along with current tcpdata buffer to the work buffer and then copy
 657            * work buffer to tcpdata buffer to continue building up tcpdata buffer to contain
 658            * a single hex string.
 659            */
 660           switch (num_items_scanned)
 661             {
 662             case 1:
 663               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s", tcpdatabuf,
 664                           hex1);
 665               break;
 666             case 2:
 667               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s",
 668                           tcpdatabuf, hex1, hex2);
 669               break;
 670             case 3:
 671               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s",
 672                           tcpdatabuf, hex1, hex2, hex3);
 673               break;
 674             default:
 675               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s",
 676                           tcpdatabuf, hex1, hex2, hex3, hex4);
 677             }
 678           memcpy (tcpdatabuf, workbuf, ISERIES_PKT_ALLOC_SIZE);
 679         }
 680
 681       /*
 682        * If we see the identifier for the next packet then rewind and set
 683        * isCurrentPacket FALSE
 684        */
 685       if ((strncmp (data + 80, ISERIES_PKT_MAGIC_STR, ISERIES_PKT_MAGIC_LEN)
 686            == 0) && pktline > 1)
 687         {
 688           isCurrentPacket = FALSE;
 689           cur_off = file_tell (fh);
 690           if (cur_off == -1)
 691             {
 692               /* Error. */
 693               *err = file_error (fh);
 694               return -1;
 695             }
 696           if (file_seek (fh, cur_off - buflen, SEEK_SET, err) == -1)
 697             {
 698               return -1;
 699             }
 700         }
 701     }
 702
 703   /*
 704    * For a formated trace ensure we have read at least the IP and TCP headers otherwise
 705    * exit and pass error message to user.
 706    */
 707   if (wth->capture.iseries->tcp_formatted)
 708     {
 709       if (!IPread)
 710         {
 711           *err = WTAP_ERR_BAD_RECORD;
 712           *err_info = g_strdup ("iseries: IP header isn't valid");
 713           return -1;
 714         }
 715       if (!TCPread)
 716         {
 717           *err = WTAP_ERR_BAD_RECORD;
 718           *err_info = g_strdup ("iseries: TCP header isn't valid");
 719           return -1;
 720         }
 721     }
 722
 723   /*
 724    * Create a buffer to hold all the ASCII Hex data and populate with all the
 725    * extracted data.
 726    */
 727   asciibuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 728   if (isDATA)
 729     {
 730       /* packet contained data */
 731       if (wth->capture.iseries->tcp_formatted)
 732         {
 733           /* build string for formatted fields */
 734           g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s%s",
 735                       destmac, srcmac, type, ipheader, tcpheader, tcpdatabuf);
 736         }
 737       else
 738         {
 739           /* build string for unformatted data fields */
 740           g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s", destmac,
 741                       srcmac, type, tcpdatabuf);
 742         }
 743     }
 744   else
 745     {
 746       /* No data in the packet */
 747       g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s", destmac,
 748                   srcmac, type, ipheader, tcpheader);
 749     }
 750
 751   /*
 752    * Extract the packet length from the actual IP header; this may
 753    * differ from the capture length reported by the formatted trace.
 754    * Note: if the entire Ethernet packet is present, but the IP
 755    * packet is less than 46 bytes long, there will be padding, and
 756    * the length in the IP header won't include the padding; if
 757    * the packet length is less than the captured length, set the
 758    * packet length to the captured length.
 759    */
 760   num_items_scanned = sscanf (asciibuf + 32, "%4x", &pkt_len);
 761   wth->phdr.len = pkt_len + 14;
 762   if (wth->phdr.caplen > wth->phdr.len)
 763     wth->phdr.len = wth->phdr.caplen;
 764
 765   /* Make sure we have enough room for the packet, only create buffer if none supplied */
 766   if (pd == NULL)
 767     {
 768       buffer_assure_space (wth->frame_buffer, ISERIES_MAX_PACKET_LEN);
 769       buf = buffer_start_ptr (wth->frame_buffer);
 770       /* Convert ascii data to binary and return in the frame buffer */
 771       iseries_parse_hex_string (asciibuf, buf, strlen (asciibuf));
 772     }
 773   else
 774     {
 775       /* Convert ascii data to binary and return in the frame buffer */
 776       iseries_parse_hex_string (asciibuf, pd, strlen (asciibuf));
 777     }
 778
 779   /* free buffers allocs and return */
 780   *err = 0;
 781   g_free (asciibuf);
 782   g_free (tcpdatabuf);
 783   g_free (workbuf);
 784   return wth->phdr.len;
 785 }
 786
 787 /*
 788  * Simple routine to convert an UNICODE buffer to ASCII
 789  *
 790  * XXX - This may be possible with iconv or similar
 791  */
 792 static int
 793 iseries_UNICODE_to_ASCII (guint8 * buf, guint bytes)
 794 {
 795   guint i;
 796   guint8 *bufptr;
 797   bufptr = buf;
 798
 799   for (i = 0; i < bytes; i++)
 800     {
 801       switch (buf[i])
 802         {
 803         case 0xFE:
 804         case 0xFF:
 805         case 0x00:
 806           break;
 807         default:
 808           *bufptr = buf[i];
 809           bufptr++;
 810         }
 811       if (buf[i] == 0x0A)
 812         return i;
 813     }
 814   return i;
 815 }
 816
 817 /*
 818  * Simple routine to convert an ASCII hex string to binary data
 819  * Requires ASCII hex data and buffer to populate with binary data
 820  */
 821 static gboolean
 822 iseries_parse_hex_string (const char * ascii, guint8 * buf, int len)
 823 {
 824   int i, byte;
 825   gint hexvalue;
 826   guint8 bytevalue;
 827
 828   byte = 0;
 829   i = 0;
 830   for (;;)
 831     {
 832       if (i >= len)
 833         break;
 834       hexvalue = g_ascii_xdigit_value(ascii[i]);
 835       i++;
 836       if (hexvalue == -1)
 837         return FALSE;   /* not a valid hex digit */
 838       bytevalue = (guint8)(hexvalue << 4);
 839       if (i >= len)
 840         return FALSE;   /* only one hex digit of the byte is present */
 841       hexvalue = g_ascii_xdigit_value(ascii[i]);
 842       i++;
 843       if (hexvalue == -1)
 844         return FALSE;   /* not a valid hex digit */
 845       bytevalue |= (guint8) hexvalue;
 846       buf[byte] = bytevalue;
 847       byte++;
 848     }
 849   return TRUE;
 850 }