wiretap/ber.c

   1 /* ber.c
   2  *
   3  * Basic Encoding Rules (BER) file reading
   4  *
   5  * $Id$
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <errno.h>
  25
  26 #ifdef HAVE_SYS_STAT_H
  27 #include <sys/stat.h>
  28 #endif
  29
  30 #include "wtap-int.h"
  31 #include "file_wrappers.h"
  32 #include "buffer.h"
  33 #include "ber.h"
  34
  35
  36 #define BER_CLASS_UNI   0
  37 #define BER_CLASS_APP   1
  38 #define BER_CLASS_CON   2
  39
  40 #define BER_UNI_TAG_SEQ 16      /* SEQUENCE, SEQUENCE OF */
  41 #define BER_UNI_TAG_SET 17      /* SET, SET OF */
  42
  43 static gboolean ber_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
  44 {
  45   gint64 offset;
  46   guint8 *buf;
  47   gint64 file_size;
  48   int packet_size;
  49
  50   *err = 0;
  51
  52   offset = file_tell(wth->fh);
  53
  54   /* there is only ever one packet */
  55   if (offset != 0)
  56     return FALSE;
  57
  58   *data_offset = offset;
  59
  60   if ((file_size = wtap_file_size(wth, err)) == -1)
  61     return FALSE;
  62
  63   if (file_size > WTAP_MAX_PACKET_SIZE) {
  64     /*
  65      * Probably a corrupt capture file; don't blow up trying
  66      * to allocate space for an immensely-large packet.
  67      */
  68     *err = WTAP_ERR_BAD_FILE;
  69     *err_info = g_strdup_printf("ber: File has %" G_GINT64_MODIFIER "d-byte packet, bigger than maximum of %u",
  70                                 file_size, WTAP_MAX_PACKET_SIZE);
  71     return FALSE;
  72   }
  73   packet_size = (int)file_size;
  74
  75   buffer_assure_space(wth->frame_buffer, packet_size);
  76   buf = buffer_start_ptr(wth->frame_buffer);
  77
  78   wtap_file_read_expected_bytes(buf, packet_size, wth->fh, err, err_info);
  79
  80   wth->phdr.presence_flags = 0; /* yes, we have no bananas^Wtime stamp */
  81
  82   wth->phdr.caplen = packet_size;
  83   wth->phdr.len = packet_size;
  84
  85   wth->phdr.ts.secs = 0;
  86   wth->phdr.ts.nsecs = 0;
  87
  88   return TRUE;
  89 }
  90
  91 static gboolean ber_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header *pseudo_header _U_,
  92                               guint8 *pd, int length, int *err, gchar **err_info)
  93 {
  94   int packet_size = length;
  95
  96   /* there is only one packet */
  97   if(seek_off > 0) {
  98     *err = 0;
  99     return FALSE;
 100   }
 101
 102   if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
 103     return FALSE;
 104
 105   wtap_file_read_expected_bytes(pd, packet_size, wth->random_fh, err, err_info);
 106
 107   return TRUE;
 108 }
 109
 110 int ber_open(wtap *wth, int *err, gchar **err_info)
 111 {
 112 #define BER_BYTES_TO_CHECK 8
 113   guint8 bytes[BER_BYTES_TO_CHECK];
 114   int bytes_read;
 115   guint8 ber_id;
 116   gint8 ber_class;
 117   gint8 ber_tag;
 118   gboolean ber_pc;
 119   guint8 oct, nlb = 0;
 120   int len = 0;
 121   gint64 file_size;
 122   int offset = 0, i;
 123
 124   bytes_read = file_read(&bytes, BER_BYTES_TO_CHECK, wth->fh);
 125   if (bytes_read != BER_BYTES_TO_CHECK) {
 126     *err = file_error(wth->fh, err_info);
 127     return (*err != 0) ? -1 : 0;
 128   }
 129
 130   ber_id = bytes[offset++];
 131
 132   ber_class = (ber_id>>6) & 0x03;
 133   ber_pc = (ber_id>>5) & 0x01;
 134   ber_tag = ber_id & 0x1F;
 135
 136   /* it must be constructed and either a SET or a SEQUENCE */
 137   /* or a CONTEXT less than 32 (arbitrary) */
 138   /* XXX: do we also want to allow APPLICATION */
 139   if(!(ber_pc &&
 140        (((ber_class == BER_CLASS_UNI) && ((ber_tag == BER_UNI_TAG_SET) || (ber_tag == BER_UNI_TAG_SEQ))) ||
 141         ((ber_class == BER_CLASS_CON) && (ber_tag < 32)))))
 142     return 0;
 143
 144   /* now check the length */
 145   oct = bytes[offset++];
 146
 147   if(oct != 0x80) {
 148     /* not indefinite length encoded */
 149
 150     if(!(oct & 0x80))
 151       /* length fits into a single byte */
 152       len = oct;
 153     else {
 154       nlb = oct & 0x7F; /* number of length bytes */
 155
 156       if((nlb > 0) && (nlb <= (BER_BYTES_TO_CHECK - 2))) {
 157         /* not indefinite length and we have read enough bytes to compute the length */
 158         i = nlb;
 159         while(i--) {
 160           oct = bytes[offset++];
 161           len = (len<<8) + oct;
 162         }
 163       }
 164     }
 165
 166     len += (2 + nlb); /* add back Tag and Length bytes */
 167     file_size = wtap_file_size(wth, err);
 168
 169     if(len != file_size) {
 170       return 0; /* not ASN.1 */
 171     }
 172   } else {
 173     /* Indefinite length encoded - assume it is BER */
 174   }
 175
 176   /* seek back to the start of the file  */
 177   if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
 178     return -1;
 179
 180   wth->file_type = WTAP_FILE_BER;
 181   wth->file_encap = WTAP_ENCAP_BER;
 182   wth->snapshot_length = 0;
 183
 184   wth->subtype_read = ber_read;
 185   wth->subtype_seek_read = ber_seek_read;
 186   wth->tsprecision = WTAP_FILE_TSPREC_SEC;
 187
 188   return 1;
 189 }