#include <dnet.h>#include <pcap.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#ifndef OS_SPECIFIC_DEBUG#define OS_SPECIFIC_DEBUG 0#endif#include "../os_frame_funcs.h"  // This is the header used for all versions                                // of OS specific drivers.#include "logging.h"eth_t *eth = NULL;char *dev_to_use = NULL;pcap_t *pcap_descr = NULL;eth_addr_t source_mac;eth_addr_t dest_mac;char *src_interface=NULL;const u_char *packet_ptr=NULL;int more_frames_avail=0;int sleepable = 1;                 // By default, allow sleeping.const struct pcap_pkthdr *packet_header;//// packet_catch() - Deals with any frames that come in, and pass the filter.//pcap_handler packet_catch(u_char *args, const struct pcap_pkthdr *header, const u_char *packet){  // A better way to do this would be to copy the contents of the packet to our  // buffer.  (Assuming we can determine the size of the source buffer.)  // It would get rid of some compiler warnings.  packet_header = header;  packet_ptr = packet;  return 0;}void done_with_current_frame(){  // We don't need anything here...  But, OS specific handlers may need something.}//// allow_sleep -- should we allow get_frame to sleep at all?//void allow_sleep(int yesno){  sleepable = yesno;}//// more_frames() -- returns 1 if there are more frames to process.//int more_frames(){  if (sleepable == 0) return 1;  // If we can sleep, always say there are more                                 // frames.  return more_frames_avail;}//// get_frame(int u_sec) -- returns a pointer to a frame if there is one.//  NULL if there isn't.  u_sec is how long to sleep before returning.//char *get_frame(int u_sec){  int pcap_ret_val=0;  usleep(u_sec);  pcap_ret_val = pcap_dispatch(pcap_descr, 1, (pcap_handler)packet_catch, NULL);  if (pcap_ret_val == 1)    {      more_frames_avail = 1;      return (char *) packet_ptr;    } else {      more_frames_avail = 0;      return NULL;    }}// Return a pointer to the frame we are working against.char *get_working_frame(){  return (char *)packet_ptr;}//// setup_pcap() - Returns a handle to a pcap descr.  NULL is there is an// error.  On error, there is a message in pcapErr.//pcap_t *setup_pcap(int buf_size, int timeout, char pcapErr[PCAP_ERRBUF_SIZE]){  char pcap_err[PCAP_ERRBUF_SIZE];    //pcap error buffer  pcap_t *pcap_descr = NULL;          //pcap connection  bpf_u_int32 pcap_maskp;             //subnet mask  bpf_u_int32 pcap_netp;              //???  char pcap_filter[100];              //filter space  struct bpf_program pcap_fp;         //hold the compiled filter.  char *errbuf=NULL;                  //Buffer to catch our error.  char *pcap_compile_error = "Error running pcap compile!";  char *pcap_filter_error = "Error setting filter!";  pcap_lookupnet(dev_to_use, &pcap_netp, &pcap_maskp, pcap_err);    /* We need to be in promisc mode to grab stuff that "isn't for us" */  pcap_descr = pcap_open_live(dev_to_use, buf_size, 1, timeout, pcap_err);  if (pcap_descr == NULL)    {#if OS_SPECIFIC_DEBUG      xlogf(DEBUG_EVERYTHING, "pcap_open_live(): %s\n",pcap_err);#endif      return NULL;    }    sprintf(pcap_filter, "ether dst %s or ether dst 01:80:c2:00:00:03 and ether proto 0x888e", eth_ntoa(&source_mac));#if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "PCAP Filter : %s\n",pcap_filter);#endif  if (pcap_compile(pcap_descr, &pcap_fp, pcap_filter, 0, pcap_netp) == -1)    {      xlogf(DEBUG_NORMAL, "Error : %s\n", pcap_compile_error);      return NULL;    }  if (pcap_setfilter(pcap_descr, &pcap_fp) == -1)    {      xlogf(DEBUG_NORMAL, "Error : %s\n", pcap_filter_error);      return NULL;    }  #ifndef __OpenBSD__  if (pcap_setnonblock(pcap_descr, 1, errbuf) == -1)    {      // If we can't go in to non-blocking mode, the timers that determine      // if we are on a port that isn't smart enough to authenticate will      // break.  However, this shouldn't break the program.  It will      // just take longer to determine that there isn't anything there.      xlogf(DEBUG_NORMAL, "Couldn't go in to non-blocking state, timers won't work!\n");      xlogf(DEBUG_NORMAL, "Recieved error : %s\n",errbuf);    }#endif    return pcap_descr;}//// initalize_frame_funcs() -- If it returns NULL everything is fine.//  If not, the resulting pointer has an error message.//char *initalize_frame_funcs(char *device, int buf_size, int timeout){  char *temp = NULL;       //This will hold some temporary values.  char pcap_err[PCAP_ERRBUF_SIZE];  char *error_pcap_failure = "Couldn't set up PCAP.";#if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "Initalizing Frame handler (generic)\n");#endif  if (device == NULL) {    temp = pcap_lookupdev(pcap_err);    if (temp == NULL) {      temp = (char *)malloc(sizeof(pcap_err));      strncpy(temp, pcap_err, sizeof(pcap_err));      return temp;    }  } else {    temp = device;  }#if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "Using interface : %s\n", temp);#endif  // Stash a copy of the device name.  dev_to_use = (char *)malloc(strlen(temp)+1);  strncpy(dev_to_use, temp, strlen(temp)+1);  // +1 to pick up the null.  if ((eth = eth_open(dev_to_use)) == NULL)      return ("Couldn't open device");  // Get the Mac address.  if (eth_get(eth, &source_mac) < 0)      return ("Couldn't get MAC address");	  #if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "Got MAC address of %s\n", eth_ntoa(&source_mac));#endif  if ((pcap_descr = setup_pcap(buf_size, timeout, pcap_err)) == NULL) {    return error_pcap_failure;    }    return NULL;}// Return a pointer to the device name in use.char *get_dev_name(){  return dev_to_use;}// // get_src_mac() - Return a pointer to a copy of the MAC address.//u_char *get_src_mac(){  eth_addr_t *ret_mac=NULL;  ret_mac = (eth_addr_t *)malloc(ETH_ADDR_LEN);   //Size of MAC address.  memcpy(ret_mac, &source_mac, ETH_ADDR_LEN);#if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "Source MAC address is %s\n", eth_ntoa(&source_mac));           //Sanity check our return value:  xlogf(DEBUG_EVERYTHING, "Return MAC address is %s\n", eth_ntoa(ret_mac));#endif  return (u_char *)ret_mac;}u_char *get_dst_mac(){  eth_addr_t *ret_mac=NULL;  ret_mac = (eth_addr_t *)malloc(ETH_ADDR_LEN);   //Size of MAC address.  memcpy(ret_mac, &dest_mac, ETH_ADDR_LEN);#if OS_SPECIFIC_DEBUG  xlogf(DEBUG_EVERYTHING, "Destination MAC address is %s\n",      eth_ntoa(&dest_mac));           //Sanity check our return value:  xlogf(DEBUG_EVERYTHING, "Return MAC address is %s\n", eth_ntoa(ret_mac));#endif  return (u_char *)ret_mac;}// Send a frame.char *send_frame(u_char *frame_ptr, int frame_size){#if OS_SPECIFIC_DEBUG  struct eth_hdr *eth_hdr = (struct eth_hdr *)frame_ptr;  xlogf(DEBUG_EVERYTHING, "Sending frame with size of %d.\n",frame_size);  xlogf(DEBUG_EVERYTHING, "(Send Frame)Sending to %s\n",      eth_ntoa(&eth_hdr->eth_dst));  xlogf(DEBUG_EVERYTHING, "Source address from frame is %s",      eth_ntoa(&eth_hdr->eth_src));  xlogf(DEBUG_EVERYTHING, "Destination address from frame is %s",      eth_ntoa(&eth_hdr->eth_dst));  xlogf(DEBUG_EVERYTHING, "Frame type is : %x\n", ntohs(eth_hdr->eth_type));#endif    if (eth_send(eth, frame_ptr, frame_size) < 0)    {#if OS_SPECIFIC_DEBUG      xlogf(DEBUG_EVERYTHING, "Write error in send_frame()\n");#endif      return ("Error sending frame");    }  return NULL;}int shutdown_frame_funcs(){  if (dev_to_use != NULL)    {      free(dev_to_use);      dev_to_use = NULL;    }  // Shutdown libdnet  if (eth != NULL)    {      eth = eth_close(eth);    }  // Shutdown PCAP  if (pcap_descr != NULL)    {      pcap_close(pcap_descr);      if (pcap_descr != NULL) 	{	  	  free(pcap_descr);	  pcap_descr = NULL;	}    }  return 0;}