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->len > len))
  81                 return -ENOMEM;
  82
  83         if (unlikely(hdr->len == 0))
  84                 return -EINVAL; /* Bogus packet */
  85
  86         ret = read(fd, packet, hdr->len);
  87         if (unlikely(ret != hdr->len))
  88                 return -EIO;
  89
  90         return sizeof(*hdr) + hdr->len;
  91 }
  92
  93 static void pcap_rw_fsync_pcap(int fd)
  94 {
  95         fdatasync(fd);
  96 }
  97
  98 static int pcap_rw_prepare_writing_pcap(int fd)
  99 {
 100         set_ioprio_rt();
 101         return 0;
 102 }
 103
 104 static int pcap_rw_prepare_reading_pcap(int fd)
 105 {
 106         set_ioprio_rt();
 107         return 0;
 108 }
 109
 110 struct pcap_file_ops pcap_rw_ops __read_mostly = {
 111         .name = "read-write",
 112         .pull_file_header = pcap_rw_pull_file_header,
 113         .push_file_header = pcap_rw_push_file_header,
 114         .write_pcap_pkt = pcap_rw_write_pcap_pkt,
 115         .read_pcap_pkt = pcap_rw_read_pcap_pkt,
 116         .fsync_pcap = pcap_rw_fsync_pcap,
 117         .prepare_writing_pcap = pcap_rw_prepare_writing_pcap,
 118         .prepare_reading_pcap = pcap_rw_prepare_reading_pcap,
 119 };
 120
 121 int init_pcap_rw(int jumbo_support)
 122 {
 123         return pcap_ops_group_register(&pcap_rw_ops, PCAP_OPS_RW);
 124 }
 125
 126 void cleanup_pcap_rw(void)
 127 {
 128         pcap_ops_group_unregister(PCAP_OPS_RW);
 129 }