src/pcap_rw.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2009, 2010, 2011 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdint.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <errno.h>
  13
  14 #include "pcap.h"
  15 #include "built_in.h"
  16 #include "xsys.h"
  17 #include "xio.h"
  18 #include "die.h"
  19
  20 static int pcap_rw_pull_file_header(int fd)
  21 {
  22         ssize_t ret;
  23         struct pcap_filehdr hdr;
  24
  25         ret = read(fd, &hdr, sizeof(hdr));
  26         if (unlikely(ret != sizeof(hdr)))
  27                 return -EIO;
  28
  29         pcap_validate_header(&hdr);
  30
  31         return 0;
  32 }
  33
  34 static int pcap_rw_push_file_header(int fd)
  35 {
  36         ssize_t ret;
  37         struct pcap_filehdr hdr;
  38
  39         memset(&hdr, 0, sizeof(hdr));
  40         pcap_prepare_header(&hdr, LINKTYPE_EN10MB, 0,
  41                             PCAP_DEFAULT_SNAPSHOT_LEN);
  42
  43         ret = write_or_die(fd, &hdr, sizeof(hdr));
  44         if (unlikely(ret != sizeof(hdr))) {
  45                 whine("Failed to write pkt file header!\n");
  46                 return -EIO;
  47         }
  48
  49         return 0;
  50 }
  51
  52 static ssize_t pcap_rw_write_pcap_pkt(int fd, struct pcap_pkthdr *hdr,
  53                                       uint8_t *packet, size_t len)
  54 {
  55         ssize_t ret = write_or_die(fd, hdr, sizeof(*hdr));
  56         if (unlikely(ret != sizeof(*hdr))) {
  57                 whine("Failed to write pkt header!\n");
  58                 return -EIO;
  59         }
  60
  61         if (unlikely(hdr->len != len))
  62                 return -EINVAL;
  63
  64         ret = write_or_die(fd, packet, hdr->len);
  65         if (unlikely(ret != hdr->len)) {
  66                 whine("Failed to write pkt payload!\n");
  67                 return -EIO;
  68         }
  69
  70         return sizeof(*hdr) + hdr->len;
  71 }
  72
  73 static ssize_t pcap_rw_read_pcap_pkt(int fd, struct pcap_pkthdr *hdr,
  74                                      uint8_t *packet, size_t len)
  75 {
  76         ssize_t ret = read(fd, hdr, sizeof(*hdr));
  77         if (unlikely(ret != sizeof(*hdr)))
  78                 return -EIO;
  79
  80         if (unlikely(hdr->caplen == 0 || hdr->caplen > len))
  81                 return -EINVAL; /* Bogus packet */
  82
  83         ret = read(fd, packet, hdr->caplen);
  84         if (unlikely(ret != hdr->caplen))
  85                 return -EIO;
  86
  87         return sizeof(*hdr) + hdr->caplen;
  88 }
  89
  90 static void pcap_rw_fsync_pcap(int fd)
  91 {
  92         fdatasync(fd);
  93 }
  94
  95 static int pcap_rw_prepare_writing_pcap(int fd)
  96 {
  97         set_ioprio_rt();
  98         return 0;
  99 }
 100
 101 static int pcap_rw_prepare_reading_pcap(int fd)
 102 {
 103         set_ioprio_rt();
 104         return 0;
 105 }
 106
 107 struct pcap_file_ops pcap_rw_ops __read_mostly = {
 108         .name = "read-write",
 109         .pull_file_header = pcap_rw_pull_file_header,
 110         .push_file_header = pcap_rw_push_file_header,
 111         .write_pcap_pkt = pcap_rw_write_pcap_pkt,
 112         .read_pcap_pkt = pcap_rw_read_pcap_pkt,
 113         .fsync_pcap = pcap_rw_fsync_pcap,
 114         .prepare_writing_pcap = pcap_rw_prepare_writing_pcap,
 115         .prepare_reading_pcap = pcap_rw_prepare_reading_pcap,
 116 };
 117
 118 int init_pcap_rw(int jumbo_support)
 119 {
 120         return pcap_ops_group_register(&pcap_rw_ops, PCAP_OPS_RW);
 121 }
 122
 123 void cleanup_pcap_rw(void)
 124 {
 125         pcap_ops_group_unregister(PCAP_OPS_RW);
 126 }