lib/pcap.c

   1 /*
   2  * Copyright (c) 2009, 2010 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "pcap.h"
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <string.h>
  23 #include "compiler.h"
  24 #include "ofpbuf.h"
  25 #include "vlog.h"
  26
  27 VLOG_DEFINE_THIS_MODULE(pcap);
  28
  29 struct pcap_hdr {
  30     uint32_t magic_number;   /* magic number */
  31     uint16_t version_major;  /* major version number */
  32     uint16_t version_minor;  /* minor version number */
  33     int32_t thiszone;        /* GMT to local correction */
  34     uint32_t sigfigs;        /* accuracy of timestamps */
  35     uint32_t snaplen;        /* max length of captured packets */
  36     uint32_t network;        /* data link type */
  37 };
  38 BUILD_ASSERT_DECL(sizeof(struct pcap_hdr) == 24);
  39
  40 struct pcaprec_hdr {
  41     uint32_t ts_sec;         /* timestamp seconds */
  42     uint32_t ts_usec;        /* timestamp microseconds */
  43     uint32_t incl_len;       /* number of octets of packet saved in file */
  44     uint32_t orig_len;       /* actual length of packet */
  45 };
  46 BUILD_ASSERT_DECL(sizeof(struct pcaprec_hdr) == 16);
  47
  48 FILE *
  49 pcap_open(const char *file_name, const char *mode)
  50 {
  51     FILE *file;
  52
  53     assert(!strcmp(mode, "rb") || !strcmp(mode, "wb"));
  54
  55     file = fopen(file_name, mode);
  56     if (file == NULL) {
  57         VLOG_WARN("%s: failed to open pcap file for %s",
  58                   file_name, mode[0] == 'r' ? "reading" : "writing");
  59         return NULL;
  60     }
  61
  62     if (mode[0] == 'r') {
  63         if (!pcap_read_header(file)) {
  64             fclose(file);
  65             return NULL;
  66         }
  67     } else {
  68         pcap_write_header(file);
  69     }
  70     return file;
  71 }
  72
  73 int
  74 pcap_read_header(FILE *file)
  75 {
  76     struct pcap_hdr ph;
  77     if (fread(&ph, sizeof ph, 1, file) != 1) {
  78         int error = ferror(file) ? errno : EOF;
  79         VLOG_WARN("failed to read pcap header: %s", ovs_retval_to_string(error));
  80         return error;
  81     }
  82     if (ph.magic_number != 0xa1b2c3d4 && ph.magic_number != 0xd4c3b2a1) {
  83         VLOG_WARN("bad magic 0x%08"PRIx32" reading pcap file "
  84                   "(expected 0xa1b2c3d4 or 0xd4c3b2a1)", ph.magic_number);
  85         return EPROTO;
  86     }
  87     return 0;
  88 }
  89
  90 void
  91 pcap_write_header(FILE *file)
  92 {
  93     /* The pcap reader is responsible for figuring out endianness based on the
  94      * magic number, so the lack of htonX calls here is intentional. */
  95     struct pcap_hdr ph;
  96     ph.magic_number = 0xa1b2c3d4;
  97     ph.version_major = 2;
  98     ph.version_minor = 4;
  99     ph.thiszone = 0;
 100     ph.sigfigs = 0;
 101     ph.snaplen = 1518;
 102     ph.network = 1;             /* Ethernet */
 103     ignore(fwrite(&ph, sizeof ph, 1, file));
 104 }
 105
 106 int
 107 pcap_read(FILE *file, struct ofpbuf **bufp)
 108 {
 109     struct pcaprec_hdr prh;
 110     struct ofpbuf *buf;
 111     void *data;
 112     size_t len;
 113
 114     *bufp = NULL;
 115
 116     /* Read header. */
 117     if (fread(&prh, sizeof prh, 1, file) != 1) {
 118         int error = ferror(file) ? errno : EOF;
 119         VLOG_WARN("failed to read pcap record header: %s",
 120                   ovs_retval_to_string(error));
 121         return error;
 122     }
 123
 124     /* Calculate length. */
 125     len = prh.incl_len;
 126     if (len > 0xffff) {
 127         uint32_t swapped_len = (((len & 0xff000000) >> 24) |
 128                                 ((len & 0x00ff0000) >>  8) |
 129                                 ((len & 0x0000ff00) <<  8) |
 130                                 ((len & 0x000000ff) << 24));
 131         if (swapped_len > 0xffff) {
 132             VLOG_WARN("bad packet length %zu or %"PRIu32" "
 133                       "reading pcap file",
 134                       len, swapped_len);
 135             return EPROTO;
 136         }
 137         len = swapped_len;
 138     }
 139
 140     /* Read packet. */
 141     buf = ofpbuf_new(len);
 142     data = ofpbuf_put_uninit(buf, len);
 143     if (fread(data, len, 1, file) != 1) {
 144         int error = ferror(file) ? errno : EOF;
 145         VLOG_WARN("failed to read pcap packet: %s",
 146                   ovs_retval_to_string(error));
 147         ofpbuf_delete(buf);
 148         return error;
 149     }
 150     *bufp = buf;
 151     return 0;
 152 }
 153
 154 void
 155 pcap_write(FILE *file, struct ofpbuf *buf)
 156 {
 157     struct pcaprec_hdr prh;
 158     prh.ts_sec = 0;
 159     prh.ts_usec = 0;
 160     prh.incl_len = buf->size;
 161     prh.orig_len = buf->size;
 162     ignore(fwrite(&prh, sizeof prh, 1, file));
 163     ignore(fwrite(buf->data, buf->size, 1, file));
 164 }