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 #define ISERIES_HDR_MAGIC_STR   " COMMUNICATIONS TRACE"
 127 #define ISERIES_HDR_MAGIC_LEN   21
 128 #define ISERIES_PKT_MAGIC_STR   "ETHV2"
 129 #define ISERIES_PKT_MAGIC_LEN   5
 130 #define ISERIES_LINE_LENGTH     270
 131 #define ISERIES_HDR_LINES_TO_CHECK  50
 132 #define ISERIES_PKT_LINES_TO_CHECK  4
 133 #define ISERIES_MAX_PACKET_LEN  16384
 134 #define ISERIES_MAX_TRACE_LEN   99999999
 135 #define ISERIES_PKT_ALLOC_SIZE (cap_len*2)+1
 136 #define ISERIES_FORMAT_ASCII    1
 137 #define ISERIES_FORMAT_UNICODE  2
 138
 139 static gboolean iseries_read (wtap * wth, int *err, gchar ** err_info,
 140                               gint64 *data_offset);
 141 static gboolean iseries_seek_read (wtap * wth, gint64 seek_off,
 142                                    union wtap_pseudo_header *pseudo_header,
 143                                    guint8 * pd, int len, int *err,
 144                                    gchar ** err_info);
 145 static gboolean iseries_check_file_type (wtap * wth, int *err, int format);
 146 static gint64 iseries_seek_next_packet (wtap * wth, int *err);
 147 static int iseries_parse_packet (wtap * wth, FILE_T fh,
 148                                  union wtap_pseudo_header *pseudo_header,
 149                                  guint8 * pd, int *err, gchar ** err_info);
 150 static int iseries_UNICODE_to_ASCII (guint8 * buf, guint bytes);
 151 static gboolean iseries_parse_hex_string (guint8 * ascii, guint8 * buf,
 152                                           int len);
 153
 154 int
 155 iseries_open (wtap * wth, int *err, gchar ** err_info _U_)
 156 {
 157   int bytes_read;
 158   char magic[ISERIES_HDR_MAGIC_LEN];
 159   /* UNICODE identification */
 160   char unicodemagic[ISERIES_HDR_MAGIC_LEN] =
 161     { '\xFF', '\xFE', '\x20', '\x00', '\x43', '\x00', '\x4F', '\x00', '\x4D',
 162     '\x00', '\x4D', '\x00', '\x55', '\x00', '\x4E', '\x00', '\x49', '\x00',
 163     '\x43', '\x00', '\x41'
 164   };
 165
 166   /*
 167    * Check that file starts with a valid iSeries COMMS TRACE header
 168    */
 169   errno = WTAP_ERR_CANT_READ;
 170   bytes_read = file_read (&magic, 1, sizeof magic, wth->fh);
 171   if (bytes_read != sizeof magic)
 172     {
 173       *err = file_error (wth->fh);
 174       if (*err != 0)
 175         return -1;
 176       return 0;
 177     }
 178
 179   /* Check if this is an ASCII formatted file */
 180   if (memcmp (magic, ISERIES_HDR_MAGIC_STR, ISERIES_HDR_MAGIC_LEN) == 0)
 181     {
 182       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 183         {
 184           return 0;
 185         }
 186       /*
 187        * Do some basic sanity checking to ensure we can handle the
 188        * contents of this trace
 189        */
 190       if (!iseries_check_file_type (wth, err, ISERIES_FORMAT_ASCII))
 191         {
 192           if (*err == 0)
 193             return 0;
 194           else
 195             return -1;
 196         }
 197       wth->data_offset = 0;
 198       wth->file_encap = WTAP_ENCAP_PER_PACKET;
 199       wth->file_type = WTAP_FILE_ISERIES;
 200       wth->snapshot_length = 0;
 201       wth->subtype_read = iseries_read;
 202       wth->subtype_seek_read = iseries_seek_read;
 203       wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 204       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 205         {
 206           return 0;
 207         }
 208       return 1;
 209     }
 210
 211   /* Check if this is a UNICODE formatted file */
 212   if (memcmp (magic, unicodemagic, ISERIES_HDR_MAGIC_LEN) == 0)
 213     {
 214       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 215         {
 216           return 0;
 217         }
 218       /*
 219        * Do some basic sanity checking to ensure we can handle the
 220        * contents of this trace
 221        */
 222       if (!iseries_check_file_type (wth, err, ISERIES_FORMAT_UNICODE))
 223         {
 224           if (*err == 0)
 225             return 0;
 226           else
 227             return -1;
 228         }
 229       wth->data_offset = 0;
 230       wth->file_encap = WTAP_ENCAP_PER_PACKET;
 231       wth->file_type = WTAP_FILE_ISERIES_UNICODE;
 232       wth->snapshot_length = 0;
 233       wth->subtype_read = iseries_read;
 234       wth->subtype_seek_read = iseries_seek_read;
 235       wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 236       if (file_seek (wth->fh, 0, SEEK_SET, err) == -1)
 237         {
 238           return 0;
 239         }
 240       return 1;
 241     }
 242
 243   /* Neither ASCII or UNICODE so not supported */
 244   return 0;
 245 }
 246
 247 /*
 248  * Do some basic sanity checking to ensure we can handle the
 249  * contents of this trace by checking the header page for
 250  * requisit requirements and additional information.
 251  */
 252 static gboolean
 253 iseries_check_file_type (wtap * wth, int *err, int format)
 254 {
 255   guint line;
 256   int num_items_scanned;
 257   char buf[ISERIES_LINE_LENGTH], protocol[9], tcpformat[2];
 258   guint8 *sdate;
 259
 260   /* Save trace format for passing between packets */
 261   sdate = g_malloc (10);
 262   wth->capture.iseries = g_malloc (sizeof (iseries_t));
 263   wth->capture.iseries->sdate = NULL;
 264   wth->capture.iseries->format = format;
 265   wth->capture.iseries->tcp_formatted = FALSE;
 266
 267   for (line = 0; line < ISERIES_HDR_LINES_TO_CHECK; line++)
 268     {
 269       if (file_gets (buf, ISERIES_LINE_LENGTH, wth->fh) != NULL)
 270         {
 271           /*
 272            * Check that we are dealing with an ETHERNET trace
 273            */
 274           if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 275             {
 276               iseries_UNICODE_to_ASCII (buf, ISERIES_LINE_LENGTH);
 277             }
 278           num_items_scanned = sscanf (buf,
 279                                       "   Object protocol  . . . . . . :  %8s",
 280                                       protocol);
 281           if (num_items_scanned == 1)
 282             {
 283               if (memcmp (protocol, "ETHERNET", 8) != 0)
 284                 return FALSE;
 285             }
 286
 287           /*
 288            * Determine if the data has been formatted or not
 289            */
 290           num_items_scanned = sscanf (buf,
 291                                       "   Format TCP/IP data only  . . :  %1s",
 292                                       tcpformat);
 293           if (num_items_scanned == 1)
 294             {
 295               if (strncmp (tcpformat, "Y", 1) == 0)
 296                 {
 297                   wth->capture.iseries->tcp_formatted = TRUE;
 298                 }
 299               else
 300                 {
 301                   wth->capture.iseries->tcp_formatted = FALSE;
 302                 }
 303             }
 304
 305           /*
 306            * The header is the only place where the date part of the timestamp is held, so
 307            * extract it here and store for all packets to access
 308            */
 309           num_items_scanned = sscanf (buf,
 310                                       "   Start date/Time  . . . . . . :  %8s",
 311                                       sdate);
 312           if (num_items_scanned == 1)
 313             {
 314               wth->capture.iseries->sdate = sdate;
 315             }
 316         }
 317       else
 318         {
 319           /* EOF or error. */
 320           if (file_eof (wth->fh))
 321             *err = 0;
 322           else
 323             *err = file_error (wth->fh);
 324           return FALSE;
 325         }
 326     }
 327   *err = 0;
 328   return TRUE;
 329 }
 330
 331 /*
 332  * Find the next packet and parse it; called from wtap_read().
 333  */
 334 static gboolean
 335 iseries_read (wtap * wth, int *err, gchar ** err_info, gint64 *data_offset)
 336 {
 337   gint64 offset;
 338   int pkt_len;
 339
 340   /*
 341    * Locate the next packet
 342    */
 343   offset = iseries_seek_next_packet (wth, err);
 344   if (offset < 1)
 345     return FALSE;
 346
 347   /*
 348    * Parse the packet and extract the various fields
 349    */
 350   pkt_len =
 351     iseries_parse_packet (wth, wth->fh, &wth->pseudo_header, NULL, err,
 352                           err_info);
 353   if (pkt_len == -1)
 354     return FALSE;
 355
 356   wth->data_offset = offset;
 357   *data_offset = offset;
 358   return TRUE;
 359 }
 360
 361 /*
 362  * Seeks to the beginning of the next packet, and returns the
 363  * byte offset.  Returns -1 on failure, and sets "*err" to the error.
 364  */
 365 static gint64
 366 iseries_seek_next_packet (wtap * wth, int *err)
 367 {
 368   char buf[ISERIES_LINE_LENGTH];
 369   int line;
 370   gint64 cur_off;
 371   long buflen;
 372
 373   /*
 374    * Seeks to the beginning of the next packet, and returns the
 375    * byte offset.  Returns -1 on failure, and sets "*err" to the error.
 376    */
 377   for (line = 0; line < ISERIES_MAX_TRACE_LEN; line++)
 378     {
 379       if (file_gets (buf, ISERIES_LINE_LENGTH, wth->fh) != NULL)
 380         {
 381
 382           /* Convert UNICODE to ASCII if required and determine    */
 383           /* the number of bytes to rewind to beginning of record. */
 384           if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 385             {
 386               /* buflen is #bytes to 1st 0x0A */
 387               buflen = iseries_UNICODE_to_ASCII (buf, ISERIES_LINE_LENGTH);
 388             }
 389           else
 390             {
 391               /* Else buflen is just length of the ASCII string */
 392               buflen = strlen (buf);
 393             }
 394           /* If packet header found return the offset */
 395           if (strncmp (buf + 80, ISERIES_PKT_MAGIC_STR, ISERIES_PKT_MAGIC_LEN)
 396               == 0)
 397             {
 398               /* Rewind to beginning of line */
 399               cur_off = file_tell (wth->fh);
 400               if (cur_off == -1)
 401                 {
 402                   *err = file_error (wth->fh);
 403                   return -1;
 404                 }
 405               if (file_seek (wth->fh, cur_off - buflen, SEEK_SET, err) == -1)
 406                 {
 407                   return -1;
 408                 }
 409               return cur_off - buflen;
 410             }
 411         }
 412       /* Otherwise we got an error or reached EOF */
 413       else
 414         {
 415           if (file_eof (wth->fh))
 416             {
 417               *err = 0;
 418             }
 419           else
 420             {
 421               /* We (presumably) got an error (there's no equivalent to "ferror()"
 422                  in zlib, alas, so we don't have a wrapper to check for an error). */
 423               *err = file_error (wth->fh);
 424             }
 425           return -1;
 426         }
 427     }
 428
 429   return -1;
 430 }
 431
 432 /*
 433  * Read packets in random-access fashion
 434  */
 435 static gboolean
 436 iseries_seek_read (wtap * wth, gint64 seek_off,
 437                    union wtap_pseudo_header *pseudo_header, guint8 * pd,
 438                    int len, int *err, gchar ** err_info)
 439 {
 440   int pkt_len;
 441
 442   /* seek to packet location */
 443   if (file_seek (wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
 444     return FALSE;
 445
 446   /*
 447    * Parse the packet and extract the various fields
 448    */
 449   pkt_len = iseries_parse_packet (wth, wth->random_fh, pseudo_header, pd,
 450                                   err, err_info);
 451
 452   if (pkt_len != len)
 453     {
 454       if (pkt_len != -1)
 455         {
 456           *err = WTAP_ERR_BAD_RECORD;
 457           *err_info =
 458             g_strdup_printf
 459             ("iseries: requested length %d doesn't match record length %d",
 460              len, pkt_len);
 461         }
 462       return FALSE;
 463     }
 464   return TRUE;
 465 }
 466
 467 /* Parses a packet. */
 468 static int
 469 iseries_parse_packet (wtap * wth, FILE_T fh,
 470                       union wtap_pseudo_header *pseudo_header, guint8 * pd,
 471                       int *err, gchar ** err_info)
 472 {
 473   gint64 cur_off;
 474   gboolean isValid, isCurrentPacket, IPread, TCPread, isDATA;
 475   int num_items_scanned, line, pktline, buflen;
 476   int pkt_len, cap_len, pktnum, month, day, year, hr, min, sec, csec;
 477   char direction[2], destmac[13], srcmac[13], type[5], ipheader[41],
 478     tcpheader[81];
 479   char hex1[17], hex2[17], hex3[17], hex4[17];
 480   char data[ISERIES_LINE_LENGTH * 2];
 481   guint8 *buf, *asciibuf, *tcpdatabuf, *workbuf;
 482   struct tm tm;
 483
 484   /*
 485    * Check for packet headers in first 3 lines this should handle page breaks
 486    * situations and the header lines output at each page throw and ensure we
 487    * read both the captured and packet lengths.
 488    */
 489   isValid = FALSE;
 490   for (line = 1; line < ISERIES_PKT_LINES_TO_CHECK; line++)
 491     {
 492       cur_off = file_tell (fh);
 493       if (file_gets (data, ISERIES_LINE_LENGTH, fh) == NULL)
 494         {
 495           *err = file_error (fh);
 496           if (*err == 0)
 497             {
 498               *err = WTAP_ERR_SHORT_READ;
 499             }
 500           return -1;
 501         }
 502       /* Convert UNICODE data to ASCII */
 503       if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 504         {
 505           iseries_UNICODE_to_ASCII (data, ISERIES_LINE_LENGTH);
 506         }
 507       /* look for packet header */
 508       num_items_scanned =
 509         sscanf (data,
 510                 "%6d   %1s   %6d  %d:%d:%d.%d               %12s  %12s  ETHV2   Type: %s",
 511                 &pktnum, direction, &cap_len, &hr, &min, &sec, &csec, destmac,
 512                 srcmac, type);
 513       if (num_items_scanned == 10)
 514         {
 515           /* OK! We found the packet header line */
 516           isValid = TRUE;
 517           /*
 518            * XXX - The Capture length returned by the iSeries trace doesn't seem to include the src/dest MAC
 519            * addresses or the packet type. So we add them here.
 520            */
 521           cap_len += 14;
 522           break;
 523         }
 524     }
 525
 526   /*
 527    * If no packet header found we exit at this point and inform the user.
 528    */
 529   if (!isValid)
 530     {
 531       *err = WTAP_ERR_BAD_RECORD;
 532       *err_info = g_strdup ("iseries: packet header isn't valid");
 533       return -1;
 534     }
 535
 536   /*
 537    * If we have Wiretap Header then populate it here
 538    *
 539    * XXX - Timer resolution on the iSeries is hardware dependant, the value for csec may be
 540    * different on other platforms though all the traces I've seen seem to show resolution
 541    * to Milliseconds (i.e HH:MM:SS.nnnnn) or Nanoseconds (i.e HH:MM:SS.nnnnnn)
 542    */
 543   if (wth->capture.iseries->sdate)
 544     {
 545       num_items_scanned =
 546         sscanf (wth->capture.iseries->sdate, "%d/%d/%d", &month, &day, &year);
 547       tm.tm_year = 100 + year;
 548       tm.tm_mon = month - 1;
 549       tm.tm_mday = day;
 550       tm.tm_hour = hr;
 551       tm.tm_min = min;
 552       tm.tm_sec = sec;
 553       tm.tm_isdst = -1;
 554       wth->phdr.ts.secs = mktime (&tm);
 555       /* Handle Millisecond precision for timer */
 556       if (csec > 99999)
 557         {
 558           wth->phdr.ts.nsecs = csec * 1000;
 559         }
 560       /* Handle Nanosecond precision for timer */
 561       else
 562         {
 563           wth->phdr.ts.nsecs = csec * 10000;
 564         }
 565       wth->phdr.caplen = cap_len;
 566       wth->phdr.pkt_encap = WTAP_ENCAP_ETHERNET;
 567       pseudo_header->eth.fcs_len = -1;
 568     }
 569
 570   /*
 571    * Start Reading packet contents
 572    */
 573   isCurrentPacket = TRUE;
 574   IPread = FALSE;
 575   TCPread = FALSE;
 576   isDATA = FALSE;
 577   /*
 578    * Allocate 2 work buffers to handle concatentation of the hex data block
 579    */
 580   tcpdatabuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 581   g_snprintf (tcpdatabuf, 1, "%s", "");
 582   workbuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 583   g_snprintf (workbuf, 1, "%s", "");
 584   /* loop through packet lines and breakout when the next packet header is read */
 585   pktline = 0;
 586   while (isCurrentPacket)
 587     {
 588       pktline++;
 589       /* Read the next line */
 590       if (file_gets (data, ISERIES_LINE_LENGTH, fh) == NULL)
 591         {
 592           if (file_eof (fh))
 593             {
 594               break;
 595             }
 596           else
 597             {
 598               *err = file_error (fh);
 599               if (*err == 0)
 600                 {
 601                   *err = WTAP_ERR_SHORT_READ;
 602                 }
 603               return -1;
 604             }
 605         }
 606
 607       /* Convert UNICODE data to ASCII and determine line length */
 608       if (wth->capture.iseries->format == ISERIES_FORMAT_UNICODE)
 609         {
 610           buflen = iseries_UNICODE_to_ASCII (data, ISERIES_LINE_LENGTH);
 611         }
 612       else
 613         {
 614           /* Else bytes to rewind is just length of ASCII string */
 615           buflen = strlen (data);
 616         }
 617
 618       /* If this is a IP header hex string then set flag */
 619       num_items_scanned = sscanf (data + 22, "IP Header  : %40s", ipheader);
 620       if (num_items_scanned == 1)
 621         {
 622           IPread = TRUE;
 623         }
 624
 625       /* If this is TCP header hex string then set flag */
 626       num_items_scanned = sscanf (data + 22, "TCP Header : %80s", tcpheader);
 627       if (num_items_scanned == 1)
 628         {
 629           TCPread = TRUE;
 630         }
 631
 632       /*
 633        * If there is data in the packet handle it here.
 634        *
 635        * The data header line will have the "Data . . " identifier, subsequent lines don't
 636        */
 637       num_items_scanned =
 638         sscanf (data + 27, "%16[A-Z0-9] %16[A-Z0-9] %16[A-Z0-9] %16[A-Z0-9]",
 639                 hex1, hex2, hex3, hex4);
 640       if (num_items_scanned > 0)
 641         {
 642           isDATA = TRUE;
 643           /*
 644            * Scan the data line for data blocks, depending on the number of blocks scanned
 645            * add them along with current tcpdata buffer to the work buffer and then copy
 646            * work buffer to tcpdata buffer to continue building up tcpdata buffer to contain
 647            * a single hex string.
 648            */
 649           switch (num_items_scanned)
 650             {
 651             case 1:
 652               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s", tcpdatabuf,
 653                           hex1);
 654               break;
 655             case 2:
 656               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s",
 657                           tcpdatabuf, hex1, hex2);
 658               break;
 659             case 3:
 660               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s",
 661                           tcpdatabuf, hex1, hex2, hex3);
 662               break;
 663             default:
 664               g_snprintf (workbuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s",
 665                           tcpdatabuf, hex1, hex2, hex3, hex4);
 666             }
 667           memcpy (tcpdatabuf, workbuf, ISERIES_PKT_ALLOC_SIZE);
 668         }
 669
 670       /*
 671        * If we see the identifier for the next packet then rewind and set
 672        * isCurrentPacket FALSE
 673        */
 674       if ((strncmp (data + 80, ISERIES_PKT_MAGIC_STR, ISERIES_PKT_MAGIC_LEN)
 675            == 0) && pktline > 1)
 676         {
 677           isCurrentPacket = FALSE;
 678           cur_off = file_tell (fh);
 679           if (cur_off == -1)
 680             {
 681               /* Error. */
 682               *err = file_error (fh);
 683               return -1;
 684             }
 685           if (file_seek (fh, cur_off - buflen, SEEK_SET, err) == -1)
 686             {
 687               return -1;
 688             }
 689         }
 690     }
 691
 692   /*
 693    * For a formated trace ensure we have read at least the IP and TCP headers otherwise
 694    * exit and pass error message to user.
 695    */
 696   if (wth->capture.iseries->tcp_formatted)
 697     {
 698       if (!IPread)
 699         {
 700           *err = WTAP_ERR_BAD_RECORD;
 701           *err_info = g_strdup ("iseries: IP header isn't valid");
 702           return -1;
 703         }
 704       if (!TCPread)
 705         {
 706           *err = WTAP_ERR_BAD_RECORD;
 707           *err_info = g_strdup ("iseries: TCP header isn't valid");
 708           return -1;
 709         }
 710     }
 711
 712   /*
 713    * Create a buffer to hold all the ASCII Hex data and populate with all the
 714    * extracted data.
 715    */
 716   asciibuf = g_malloc (ISERIES_PKT_ALLOC_SIZE);
 717   if (isDATA)
 718     {
 719       /* packet contained data */
 720       if (wth->capture.iseries->tcp_formatted)
 721         {
 722           /* build string for formatted fields */
 723           g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s%s",
 724                       destmac, srcmac, type, ipheader, tcpheader, tcpdatabuf);
 725         }
 726       else
 727         {
 728           /* build string for unformatted data fields */
 729           g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s", destmac,
 730                       srcmac, type, tcpdatabuf);
 731         }
 732     }
 733   else
 734     {
 735       /* No data in the packet */
 736       g_snprintf (asciibuf, ISERIES_PKT_ALLOC_SIZE, "%s%s%s%s%s", destmac,
 737                   srcmac, type, ipheader, tcpheader);
 738     }
 739
 740   /*
 741    * Extract the packet length from the actual IP header, this may differ from the capture length
 742    * reported by the formatted trace
 743    */
 744   num_items_scanned = sscanf (asciibuf + 32, "%4x", &pkt_len);
 745   wth->phdr.len = pkt_len + 14;
 746
 747   /* Make sure we have enough room for the packet, only create buffer if none supplied */
 748   if (pd == NULL)
 749     {
 750       buffer_assure_space (wth->frame_buffer, ISERIES_MAX_PACKET_LEN);
 751       buf = buffer_start_ptr (wth->frame_buffer);
 752       /* Convert ascii data to binary and return in the frame buffer */
 753       iseries_parse_hex_string (asciibuf, buf, strlen (asciibuf));
 754     }
 755   else
 756     {
 757       /* Convert ascii data to binary and return in the frame buffer */
 758       iseries_parse_hex_string (asciibuf, pd, strlen (asciibuf));
 759     }
 760
 761   /* free buffers allocs and return */
 762   *err = 0;
 763   free (asciibuf);
 764   free (tcpdatabuf);
 765   free (workbuf);
 766   return wth->phdr.len;
 767 }
 768
 769 /*
 770  * Simple routine to convert an UNICODE buffer to ASCII
 771  *
 772  * XXX - This may be possible with iconv or similar
 773  */
 774 static int
 775 iseries_UNICODE_to_ASCII (guint8 * buf, guint bytes)
 776 {
 777   guint i;
 778   guint8 *bufptr;
 779   bufptr = buf;
 780
 781   for (i = 0; i < bytes; i++)
 782     {
 783       switch (buf[i])
 784         {
 785         case 0xFE:
 786         case 0xFF:
 787         case 0x00:
 788           break;
 789         default:
 790           *bufptr = buf[i];
 791           bufptr++;
 792         }
 793       if (buf[i] == 0x0A)
 794         return i;
 795     }
 796   return i;
 797 }
 798
 799 /*
 800  * Simple routine to convert an ASCII hex string to binary data
 801  * Requires ASCII hex data and buffer to populate with binary data
 802  */
 803 static gboolean
 804 iseries_parse_hex_string (guint8 * ascii, guint8 * buf, int len)
 805 {
 806   int i, byte;
 807   char hexvalue[3] = { 0, 0, 0 };
 808
 809   byte = 0;
 810   for (i = 0; i < len; i++)
 811     {
 812       hexvalue[0] = ascii[i];
 813       i++;
 814       hexvalue[1] = ascii[i];
 815       buf[byte] = (guint8) strtoul (hexvalue, NULL, 16);
 816       byte++;
 817     }
 818   return TRUE;
 819 }