#define HAVE_REMOTE
#define MAX_BUF_SIZE 1024
#define snprintf _snprintf
 
#define ETH_ALEN 6
#define IP_ALEN 4
 
#define ARP_REQUEST 1
#define ARP_REPLY 2
 
#include <stdlib.h>
#include <stdio.h>
#include <pcap.h>
 
#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "Ws2_32.lib")
 
 
 
/*
 * Our data types
 *
 */
 
typedef struct ethern_hdr
{
  unsigned char ether_dhost[6];  // dest Ethernet address
  unsigned char ether_shost[6];  // source Ethernet address
  unsigned short ether_type;     // protocol (16-bit)
} ETHDR, *PETHDR;
 
typedef struct ipaddress
{
  unsigned char byte1;
  unsigned char byte2;
  unsigned char byte3;
  unsigned char byte4;
} IPADDRESS;
 
typedef struct iphdr
{
  unsigned char  ver_ihl;        // Version (4 bits) + Internet header length (4 bits)
  unsigned char  tos;            // Type of service 
  unsigned short tlen;           // Total length 
  unsigned short identification; // Identification
  unsigned short flags_fo;       // Flags (3 bits) + Fragment offset (13 bits)
  unsigned char  ttl;            // Time to live
  unsigned char  proto;          // Protocol
  unsigned short crc;            // Header checksum
  IPADDRESS      saddr;      // Source address
  IPADDRESS      daddr;      // Destination address
  unsigned int   opt;        // Option + padding
} IPHDR, *PIPHDR;
 
typedef struct udpheader
{
  unsigned short sport;          // Source port
  unsigned short dport;          // Destination port
  unsigned short len;            // Datagram length
  unsigned short crc;            // Checksum
} UDPHDR, *PUDPHDR;
 
 
 
/*
 * Function forward declarations.
 *
 */
 
void packet_handler(u_char *param, const struct pcap_pkthdr *header, 
					const u_char *pkt_data);
void MAC2String(unsigned char pMAC[6], char *pOutput, int pOutputLen);
void stringify(char *pInput, int pInputLen, char *pOutput);
void processIP4(PIPHDR pIPHdr);
void processUDP(PUDPHDR pUDPHdr, int pTotLen);
 
 
/*
 * Program entry point
 *
 */
 
int main(int argc, char **argv)
{
  int lRetVal = 0;
  pcap_if_t *lAllDevs = NULL;
  pcap_if_t *lDevice = NULL;
  char lTemp[PCAP_ERRBUF_SIZE];
  char lAdapter[MAX_BUF_SIZE + 1];
  int lCounter = 0;
  int lIFCnum = 0;
  pcap_t *lIFCHandle = NULL;
  struct bpf_program lFCode;
  unsigned int lNetMask = 0;
 
 
 
 
  /*
   * Open device list.
   *
   */
 
  if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &lAllDevs, lTemp) == -1)
  {
    printf("Error in pcap_findalldevs_ex() : %s\n", lTemp);
    lRetVal = 1;
    goto END;
  }
 
 
 
  /*
   * Print device name + description.
   *
   */
 
  lCounter = 0;
  for(lDevice = lAllDevs; lDevice; lDevice = lDevice->next, lCounter++)
  {
    printf("\n%d. %s\n    ", lCounter, lDevice->name);
 
    if (lDevice->name)
      printf("%d : (%s)\n", lCounter, lDevice->description);
    else
      printf(" (%d : No description available)\n", lCounter);
  }
 
 
 
  /*
   * Dialog which adapter to open.
   *
   */
 
  printf("\n\nOn which adapter do you want to start the sniffer : ");
  scanf("%d", &lIFCnum);
  if ((lIFCnum > 9 && lIFCnum < 0))
  {
    printf("The adapter you chose does not exist\n");
	lRetVal = 2;
	goto END;
  }
 
 
 
  ZeroMemory(lAdapter, sizeof(lAdapter));
  lCounter = 0;
 
  for(lDevice = lAllDevs; lDevice; lDevice = lDevice->next, lCounter++)
  {
    if (lCounter == lIFCnum)
    {
      strcpy(lAdapter, lDevice->name);
      break;
    }
  }
 
 
 
  /*
   * Open interface.
   *
   */
 
  if ((lIFCHandle = pcap_open(lAdapter, 65536, PCAP_OPENFLAG_PROMISCUOUS, 
	                          1000, NULL, lTemp)) == NULL)
  {
    fprintf(stderr,"\nUnable to open the adapter.\n");
    lRetVal = 5;
	goto END;
  }
 
 
 
 
 
  /* 
   * Compiling + setting the filter
   *
   */
 
  if (lDevice->addresses != NULL)
    lNetMask = ((struct sockaddr_in *)(lDevice->addresses->netmask))->sin_addr.S_un.S_addr;
  else
    lNetMask = 0xffffff;	
 
 
  ZeroMemory(&lFCode, sizeof(lFCode));
  if (pcap_compile(lIFCHandle, &lFCode, "", 1, lNetMask) < 0)
  {
    printf("Unable to compile the packet filter.\n");
    lRetVal = 3;
	goto END;
  }
 
 
  if (pcap_setfilter(lIFCHandle, &lFCode) < 0)
  {
    printf("Error setting the filter.\n");
    lRetVal = 4;
	goto END;
  }
 
  // We dont need this list anymore.
  pcap_freealldevs(lAllDevs);
 
  // Start intercepting data packets.
  pcap_loop(lIFCHandle, 0, packet_handler, NULL);
 
 
 
END:
 
  /*
   * Release all allocated resources.
   *
   */
 
  if (lAllDevs)
    pcap_freealldevs(lAllDevs);
 
 
 
  return(lRetVal);
}
 
 
 
 
 
/* 
 * Callback function invoked by libpcap for every incoming packet 
 *
 */
 
void packet_handler(u_char *param, const struct pcap_pkthdr *header, 
					const u_char *pkt_data)
{
  struct tm *ltime;
  char timestr[16];
  time_t local_tv_sec;
  PETHDR lEHdr = (PETHDR) pkt_data;
  char lSrcMAC[64];
  char lDstMAC[64];
  char lProto[MAX_BUF_SIZE + 1];
 
 
  ZeroMemory(lDstMAC, sizeof(lDstMAC));
  ZeroMemory(lSrcMAC, sizeof(lSrcMAC));
  ZeroMemory(lProto, sizeof(lProto));
 
 
  /*
   * Convert the timestamp to readable format
   *
   */
 
  local_tv_sec = header->ts.tv_sec;
  ltime=localtime(&local_tv_sec);
  strftime( timestr, sizeof timestr, "%H:%M:%S", ltime);
 
 
  MAC2String(lEHdr->ether_shost, lSrcMAC, sizeof(lSrcMAC) - 1);
  MAC2String(lEHdr->ether_dhost, lDstMAC, sizeof(lDstMAC) - 1);
  printf("\n\nTIME\t%s.%06d\nPHYS\t%s -> %s\n", timestr, header->ts.tv_usec,
	     lSrcMAC, lDstMAC);
 
 
 
  /*
   * Read source + destination MAC addresses
   *
   */
 
  switch (htons(lEHdr->ether_type))
  {
    case 0x0800 : printf("IPv4");
                  processIP4((PIPHDR) (pkt_data + 14));
                  break;
  }
}
 
 
 
/*
 *
 *
 */
 
void MAC2String(unsigned char pMAC[6], char *pOutput, int pOutputLen)
{
  if (pOutput && pOutputLen > 0)
  {
    snprintf(pOutput, pOutputLen, "%02X:%02X:%02X:%02X:%02X:%02X", pMAC[0], 
             pMAC[1], pMAC[2], pMAC[3], pMAC[4], pMAC[5]);
  }
}
 
 
 
/*
 * Process IP packet
 *
 */
 
void processIP4(PIPHDR pIPHdr)
{
  int lIPLen = (pIPHdr->ver_ihl & 0xf) * 4;
  int lTotLen = ntohs(pIPHdr->tlen);
 
  printf("\tHdr lenght : %d\tTot length : %d\n", lIPLen, lTotLen);
  printf("\t%d.%d.%d.%d -> %d.%d.%d.%d\n", pIPHdr->saddr.byte1, 
	  pIPHdr->saddr.byte2, pIPHdr->saddr.byte3, pIPHdr->saddr.byte4,
	  pIPHdr->daddr.byte1, pIPHdr->daddr.byte2, pIPHdr->daddr.byte3, 
	  pIPHdr->daddr.byte4);
 
 
  /*
   *
   *
   */
 
  if (pIPHdr->proto == 17)
    processUDP((PUDPHDR) ((u_char*) pIPHdr + lIPLen), lTotLen);
}
 
 
 
 
 
/* 
 * Process UDP packet
 *
 */
 
void processUDP(PUDPHDR pUDPHdr, int pTotLen)
{
  u_short sport = ntohs(pUDPHdr->sport);
  u_short dport = ntohs(pUDPHdr->dport);
  int lDataLen = pTotLen - sizeof(IPHDR) - sizeof(UDPHDR);
  char lData[MAX_BUF_SIZE + 1];
  char lRealData[MAX_BUF_SIZE + 1];
 
  ZeroMemory(lData, sizeof(lData));
  ZeroMemory(lRealData, sizeof(lRealData));
 
  strncpy(lData, (unsigned char *) pUDPHdr + sizeof(UDPHDR), lDataLen);
  stringify(lData, lDataLen, lRealData);
 
  printf("UDP\tsport %d -> dport %d\n", sport, dport);
  printf("\tLen : %d\tData : \"%s\"\n", lDataLen, lRealData);
}
 
 
 
 
/*
 *
 *
 */
 
void stringify(char *pInput, int pInputLen, char *pOutput)
{
  int lCounter = 0;
 
  for (;lCounter < pInputLen; lCounter++)
  {
    if (pInput[lCounter] < 32 || pInput[lCounter] > 176)
      pOutput[lCounter] = '.';
	else
      pOutput[lCounter] = pInput[lCounter];
  }
}

using System.IO;
 
namespace Files
{
    public class Files
    {
        static void Main(string[] args)
        {
            string[] lFiles;
 
            lFiles = Directory.GetFiles("c:\\");
 
            foreach (string lFile in lFiles)
                System.Console.WriteLine(lFile);
        }
    }
}