/*
 * decpcap.c
 *
 * Copyright (c) 2004-2006,2011 Arnout Engelen
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 *USA.
 *
 */

#include "decpcap.h"
#include <net/ethernet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
#include <netinet/tcp.h>
#include <pcap.h>
#include <string.h> // for memcpy
#include <sys/types.h>

#define DP_DEBUG 0
bool catchall = false;
/* functions to set up a handle (which is basically just a pcap handle) */

struct dp_handle *dp_fillhandle(pcap_t *phandle) {
  struct dp_handle *retval =
      (struct dp_handle *)malloc(sizeof(struct dp_handle));
  int i;
  retval->pcap_handle = phandle;

  for (i = 0; i < dp_n_packet_types; i++) {
    retval->callback[i] = NULL;
  }

  retval->linktype = pcap_datalink(retval->pcap_handle);

  switch (retval->linktype) {
  case (DLT_EN10MB):
    fprintf(stdout, "Ethernet link detected\n");
    break;
  case (DLT_PPP):
    fprintf(stdout, "PPP link detected\n");
    break;
  case (DLT_LINUX_SLL):
    fprintf(stdout, "Linux Cooked Socket link detected\n");
    break;
  default:
    fprintf(stdout, "No PPP or Ethernet link: %d\n", retval->linktype);
    // TODO maybe error? or 'other' callback?
    break;
  }

  return retval;
}

struct dp_handle *dp_open_offline(char *fname, char *ebuf) {
  pcap_t *temp = pcap_open_offline(fname, ebuf);

  if (temp == NULL) {
    return NULL;
  }

  return dp_fillhandle(temp);
}

struct dp_handle *dp_open_live(const char *device, int snaplen, int promisc,
                               int to_ms, char *filter, char *errbuf) {
  struct bpf_program fp; // compiled filter program
  bpf_u_int32 maskp;     // subnet mask
  bpf_u_int32 netp;      // interface IP

  pcap_t *temp = pcap_open_live(device, snaplen, promisc, to_ms, errbuf);

  if (temp == NULL) {
    return NULL;
  }

  if (filter != NULL) {
    pcap_lookupnet(device, &netp, &maskp, errbuf);

    /* Compile the filter */
    if (pcap_compile(temp, &fp, filter, 1, netp) == -1) {
      fprintf(stderr,
              "Error calling pcap_compile for filter on device %s: %s\n",
              device, pcap_geterr(temp));
      return NULL;
    }

    /* set the filter */
    if (pcap_setfilter(temp, &fp) == -1) {
      fprintf(stderr, "Error setting capture filter on device %s: %s\n", device,
              pcap_geterr(temp));
      return NULL;
    }
  }

  return dp_fillhandle(temp);
}

/* function to get packet statistics, e.g. dropped packets */

dp_stat dp_stats(struct dp_handle* handle)
{
  struct pcap_stat ps;
  if(pcap_stats(handle->pcap_handle, &ps) == PCAP_ERROR)
  {
      fprintf(stderr, "Error getting pcap_stats: %s\n", 
              pcap_geterr(handle->pcap_handle));
      ps.ps_recv   = 0;
      ps.ps_drop   = 0;
      ps.ps_ifdrop = 0;
      return ps;
  }
  return ps;
}

/* functions to add callbacks */

void dp_addcb(struct dp_handle *handle, enum dp_packet_type type,
              dp_callback callback) {
  handle->callback[type] = callback;
}

/* functions for parsing the payloads */

void dp_parse_tcp(struct dp_handle *handle, const dp_header *header,
                  const u_char *packet) {
  // const struct tcphdr * tcp = (struct tcphdr *) packet;
  // u_char * payload = (u_char *) packet + sizeof (struct tcphdr);

  if (handle->callback[dp_packet_tcp] != NULL) {
    int done =
        (handle->callback[dp_packet_tcp])(handle->userdata, header, packet);
    if (done)
      return;
  }
  // TODO: maybe `pass on' payload to lower-level protocol parsing
}

void dp_parse_udp(struct dp_handle *handle, const dp_header *header,
                  const u_char *packet) {

  if (handle->callback[dp_packet_udp] != NULL) {
    int done =
        (handle->callback[dp_packet_udp])(handle->userdata, header, packet);
    if (done)
      return;
  }
  // TODO: maybe `pass on' payload to lower-level protocol parsing
}

void dp_parse_ip(struct dp_handle *handle, const dp_header *header,
                 const u_char *packet) {
  const struct ip *ip = (struct ip *)packet;
  if (DP_DEBUG) {
    fprintf(stdout, "Looking at packet with length %ud\n", header->len);
  }
  u_char *payload = (u_char *)packet + sizeof(struct ip);

  if (handle->callback[dp_packet_ip] != NULL) {
    int done =
        (handle->callback[dp_packet_ip])(handle->userdata, header, packet);
    if (done)
      return;
  }
  switch (ip->ip_p) {
  case IPPROTO_TCP:
    dp_parse_tcp(handle, header, payload);
    break;
  case IPPROTO_UDP:
    if (catchall)
      dp_parse_udp(handle, header, payload);
    break;
  default:
    // TODO: maybe support for non-tcp IP packets
    break;
  }
}

void dp_parse_ip6(struct dp_handle *handle, const dp_header *header,
                  const u_char *packet) {
  const struct ip6_hdr *ip6 = (struct ip6_hdr *)packet;
  u_char *payload = (u_char *)packet + sizeof(struct ip6_hdr);

  if (handle->callback[dp_packet_ip6] != NULL) {
    int done =
        (handle->callback[dp_packet_ip6])(handle->userdata, header, packet);
    if (done)
      return;
  }
  switch ((ip6->ip6_ctlun).ip6_un1.ip6_un1_nxt) {
  case IPPROTO_TCP:
    dp_parse_tcp(handle, header, payload);
    break;
  case IPPROTO_UDP:
    if (catchall)
      dp_parse_udp(handle, header, payload);
    break;
  default:
    // TODO: maybe support for non-tcp ipv6 packets
    break;
  }
}

void dp_parse_ethernet(struct dp_handle *handle, const dp_header *header,
                       const u_char *packet) {
  const struct ether_header *ethernet = (struct ether_header *)packet;
  u_char *payload = (u_char *)packet + sizeof(struct ether_header);
  u_int16_t protocol = 0;

  /* call handle if it exists */
  if (handle->callback[dp_packet_ethernet] != NULL) {
    int done = (handle->callback[dp_packet_ethernet])(handle->userdata, header,
                                                      packet);

    /* return if handle decides we're done */
    if (done)
      return;
  }

  /* parse payload */
  protocol = ntohs(ethernet->ether_type);
  switch (protocol) {
  case ETHERTYPE_IP:
    dp_parse_ip(handle, header, payload);
    break;
  case ETHERTYPE_IPV6:
    dp_parse_ip6(handle, header, payload);
    break;
  default:
    // TODO: maybe support for other protocols apart from IPv4 and IPv6
    break;
  }
}

/* ppp header, i hope ;) */
/* glanced from ethereal, it's 16 bytes, and the payload packet type is
 * in the last 2 bytes... */
struct ppp_header {
  u_int16_t dummy1;
  u_int16_t dummy2;
  u_int16_t dummy3;
  u_int16_t dummy4;
  u_int16_t dummy5;
  u_int16_t dummy6;
  u_int16_t dummy7;

  u_int16_t packettype;
};

void dp_parse_ppp(struct dp_handle *handle, const dp_header *header,
                  const u_char *packet) {
  const struct ppp_header *ppp = (struct ppp_header *)packet;
  u_char *payload = (u_char *)packet + sizeof(struct ppp_header);
  u_int16_t protocol = 0;

  /* call handle if it exists */
  if (handle->callback[dp_packet_ppp] != NULL) {
    int done =
        (handle->callback[dp_packet_ppp])(handle->userdata, header, packet);

    /* return if handle decides we're done */
    if (done)
      return;
  }

  /* parse payload */
  protocol = ntohs(ppp->packettype);
  switch (protocol) {
  case ETHERTYPE_IP:
    dp_parse_ip(handle, header, payload);
    break;
  case ETHERTYPE_IPV6:
    dp_parse_ip6(handle, header, payload);
    break;
  default:
    // TODO: support for other than IPv4 and IPv6
    break;
  }
}

/* linux cooked header, i hope ;) */
/* glanced from libpcap/ssl.h */
#define SLL_ADDRLEN 8 /* length of address field */
struct sll_header {
  u_int16_t sll_pkttype;          /* packet type */
  u_int16_t sll_hatype;           /* link-layer address type */
  u_int16_t sll_halen;            /* link-layer address length */
  u_int8_t sll_addr[SLL_ADDRLEN]; /* link-layer address */
  u_int16_t sll_protocol;         /* protocol */
};

void dp_parse_linux_cooked(struct dp_handle *handle, const dp_header *header,
                           const u_char *packet) {
  const struct sll_header *sll = (struct sll_header *)packet;
  u_char *payload = (u_char *)packet + sizeof(struct sll_header);
  u_int16_t protocol = 0;

  /* call handle if it exists */
  if (handle->callback[dp_packet_sll] != NULL) {
    int done =
        (handle->callback[dp_packet_sll])(handle->userdata, header, packet);

    /* return if handle decides we're done */
    if (done)
      return;
  }

  /* parse payload */
  protocol = ntohs(sll->sll_protocol);
  switch (protocol) {
  case ETHERTYPE_IP:
    dp_parse_ip(handle, header, payload);
    break;
  case ETHERTYPE_IPV6:
    dp_parse_ip6(handle, header, payload);
    break;
  default:
    // TODO: support for other than IPv4 / IPv6
    break;
  }
}

/* functions to do the monitoring */
void dp_pcap_callback(u_char *u_handle, const struct pcap_pkthdr *header,
                      const u_char *packet) {
  struct dp_handle *handle = (struct dp_handle *)u_handle;
  struct dp_header;

  /* make a copy of the userdata for every packet */
  u_char *userdata_copy = (u_char *)malloc(handle->userdata_size);
  memcpy(userdata_copy, handle->userdata, handle->userdata_size);

  switch (handle->linktype) {
  case (DLT_EN10MB):
    dp_parse_ethernet(handle, header, packet);
    break;
  case (DLT_PPP):
    dp_parse_ppp(handle, header, packet);
    break;
  case (DLT_LINUX_SLL):
    dp_parse_linux_cooked(handle, header, packet);
    break;
  case (DLT_RAW):
  case (DLT_NULL):
    // hope for the best
    dp_parse_ip(handle, header, packet);
    break;
  default:
    fprintf(stdout, "Unknown linktype %d", handle->linktype);
    break;
  }
  free(userdata_copy);
}

int dp_dispatch(struct dp_handle *handle, int count, u_char *user, int size) {
  handle->userdata = user;
  handle->userdata_size = size;
  return pcap_dispatch(handle->pcap_handle, count, dp_pcap_callback,
                       (u_char *)handle);
}

int dp_setnonblock(struct dp_handle *handle, int i, char *errbuf) {
  return pcap_setnonblock(handle->pcap_handle, i, errbuf);
}

char *dp_geterr(struct dp_handle *handle) {
  return pcap_geterr(handle->pcap_handle);
}
