home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / security / netlog-1.02 / udplogger / udplog.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-17  |  5.5 KB  |  238 lines
  1. /*
  2.      udplogger - A UDP traffic logger
  3.      Copyright (C) 1993 Douglas Lee Schales, David K. Hess, David R. Safford
  4.  
  5.      Please see the file `COPYING' for the complete copyright notice.
  6.  
  7. udplog.c - 03/20/93
  8.  
  9. */
  10. #include <stdio.h>
  11. #include <sys/types.h>
  12. #include <sys/socket.h>
  13. #include <netinet/in.h>
  14. #include <netdb.h>
  15. #include <netinet/in_systm.h>
  16. #include <netinet/ip.h>
  17. #include <netinet/udp.h>
  18. #include <sys/time.h>
  19. #include <netdb.h>
  20. #include <memory.h>
  21.  
  22. extern char *optarg;
  23. extern int optind, opterr;
  24.  
  25. #include "defs.h"
  26.  
  27. struct ipaddr {
  28.      unsigned int addr:32;
  29. };
  30.  
  31. struct tcpsynout {
  32.      struct timeval tp;
  33.      unsigned long ipsrcaddr;
  34.      unsigned long ipdstaddr;
  35.      unsigned long tcpseq;
  36.      unsigned short tcpsrcport;
  37.      unsigned short tcpdstport;
  38. };
  39.  
  40. static void etherhandler(char *, int, struct timeval);
  41. static void udplog(struct ip *, struct timeval);
  42. static void udplogbin(struct tcpsynout *);
  43. static void udplogascii(struct tcpsynout *);
  44. static int isactive(struct tcpsynout *);
  45. static void udpage(struct timeval);
  46. static char *getudpportname(unsigned short);
  47. extern char *gettimestr(struct timeval);
  48.  
  49. extern void pushfilter(int);
  50.  
  51. #define LOGBINARY 0
  52. #define LOGASCII 1
  53. static int logtype = LOGBINARY;
  54. static FILE *logfile = stdout;
  55.  
  56. int resolve = 0;
  57.  
  58. extern char *getdefaultif(char *);
  59.  
  60. main(int argc, char **argv)
  61. {
  62.      char *eif = getdefaultif((char *)0);
  63.      int fd;
  64.      int c;
  65.      
  66.      while((c=getopt(argc, argv, "ni:abf:")) != -1){
  67.       switch(c){
  68.       case 'a':
  69.            logtype = LOGASCII;
  70.            break;
  71.       case 'b':
  72.            logtype = LOGBINARY;
  73.            break;
  74.       case 'n':
  75.            resolve = 0;
  76.            break;
  77.       case 'i':
  78.            eif = optarg;
  79.            break;
  80.       case 'f':
  81.            if(!(logfile = fopen(optarg, "a"))){
  82.             perror(optarg);
  83.             exit(1);
  84.            }
  85.            break;
  86.       default:
  87.            fprintf(stderr, "Unknown option: %c\n", c);
  88.            exit(1);
  89.       }
  90.      }
  91.  
  92.      fd = opennit(eif, pushfilter);
  93.      procpkts(fd, etherhandler);
  94. }
  95.  
  96. void
  97. etherhandler(char *pkt, int size, struct timeval tp)
  98. {
  99.      udplog((struct ip *)(pkt + 14), tp);
  100. }
  101.  
  102.  
  103. void
  104. udplog(struct ip *ip, struct timeval tp)
  105. {
  106.      struct udphdr *udp;
  107.      struct tcpsynout outbuf;
  108.  
  109.      udp = (struct udphdr *)(((char *)ip) + sizeof(struct ip));
  110.  
  111.      memset((char *)&outbuf.tcpseq, 0, sizeof(long));
  112.      memcpy((char *)&outbuf.tp, (char *)&tp, sizeof(struct timeval));
  113.      memcpy((char *)&outbuf.ipsrcaddr, (char *)&ip->ip_src, 4);
  114.      memcpy((char *)&outbuf.ipdstaddr, (char *)&ip->ip_dst, 4);
  115.      memcpy((char *)&outbuf.tcpsrcport, (char *)&udp->uh_sport, 2);
  116.      memcpy((char *)&outbuf.tcpdstport, (char *)&udp->uh_dport, 2);
  117.  
  118.      if(!isactive(&outbuf)){
  119.       switch(logtype){
  120.       case LOGBINARY:
  121.            udplogbin(&outbuf);
  122.            break;
  123.       case LOGASCII:
  124.            udplogascii(&outbuf);
  125.            break;
  126.       default:
  127.            fprintf(stderr, "Log type unknown: %d\n", logtype);
  128.            break;
  129.       }
  130.      }
  131.      udpage(tp);
  132. }
  133.  
  134. void
  135. udplogbin(struct tcpsynout *outbuf)
  136. {
  137.      write(fileno(logfile), (char *)outbuf, sizeof(struct tcpsynout));
  138. }
  139.  
  140. void
  141. udplogascii(struct tcpsynout *outbuf)
  142. {
  143.      struct in_addr haddr;
  144.  
  145.      fputs(gettimestr(outbuf->tp), logfile);
  146.      fprintf(logfile, " %8X ", outbuf->tcpseq);
  147.      memcpy(&haddr.s_addr, &outbuf->ipsrcaddr, 4);
  148.      fprintf(logfile, "%-21s", resolve ? cgethostbyaddr(haddr) : inet_ntoa(haddr));
  149.      fputc(' ', logfile);
  150.      fputs(getudpportname(outbuf->tcpsrcport), logfile);
  151.      fputs(" -> ", logfile);
  152.      memcpy(&haddr.s_addr, &outbuf->ipdstaddr, 4);
  153.      fprintf(logfile, "%-21s", resolve ? cgethostbyaddr(haddr) : inet_ntoa(haddr));
  154.      fputc(' ', logfile);
  155.      fputs(getudpportname(outbuf->tcpdstport), logfile);;
  156.      fputc('\n', logfile);
  157.      fflush(logfile);
  158. }
  159.  
  160. char *
  161. getudpportname(unsigned short p)
  162. {
  163.      struct servent *se;
  164.      static char result[80];
  165.  
  166.      if(resolve && (se = getservbyport((unsigned int)ntohs(p), "udp")))
  167.       strcpy(result, se->s_name);
  168.      else
  169.       sprintf(result, "%u", (unsigned int)ntohs(p));
  170.      
  171.      return result;
  172. }
  173.  
  174. struct udpactive {
  175.      struct udpactive *next;
  176.      struct tcpsynout buf;
  177. };
  178.  
  179. struct udpactive *udphead = (struct udpactive *)0;
  180.  
  181. int
  182. isactive(struct tcpsynout *buf)
  183. {
  184.      struct udpactive *rove;
  185.  
  186.      for(rove=udphead;rove;rove=rove->next){
  187.       if(!memcmp(&rove->buf.ipsrcaddr, &buf->ipsrcaddr, 4) &&
  188.          !memcmp(&rove->buf.ipdstaddr, &buf->ipdstaddr, 4) &&
  189.          !memcmp(&rove->buf.tcpsrcport, &buf->tcpsrcport, 2) &&
  190.          !memcmp(&rove->buf.tcpdstport, &buf->tcpdstport, 2)){
  191.            memcpy(&rove->buf.tp, &buf->tp, sizeof(struct timeval));
  192.            return 1;
  193.       }
  194.       /* Response? */
  195.       if(!memcmp(&rove->buf.ipsrcaddr, &buf->ipdstaddr, 4) &&
  196.          !memcmp(&rove->buf.ipdstaddr, &buf->ipsrcaddr, 4) &&
  197.          !memcmp(&rove->buf.tcpsrcport, &buf->tcpdstport, 2) &&
  198.          !memcmp(&rove->buf.tcpdstport, &buf->tcpsrcport, 2)){
  199.            memcpy(&rove->buf.tp, &buf->tp, sizeof(struct timeval));
  200.            return 1;
  201.       }
  202.      }
  203.      rove = (struct udpactive *)malloc(sizeof(struct udpactive));
  204.      rove->next = udphead;
  205.      udphead = rove;
  206.      memcpy(&rove->buf, buf, sizeof(struct tcpsynout));
  207.  
  208.      return 0;
  209. }
  210.  
  211. void
  212. udpage(struct timeval tp)
  213. {
  214.      struct udpactive *rove, *prev, *temp;
  215.  
  216.      prev=(struct udpactive *)0;
  217.      rove=udphead;
  218.      while(rove){
  219.       if((tp.tv_sec - rove->buf.tp.tv_sec) > 300){
  220.            if(prev){
  221.             prev->next = rove->next;
  222.             free(rove);
  223.             rove=prev->next;
  224.            }
  225.            else {
  226.             udphead = rove->next;
  227.             free(rove);
  228.             rove=udphead->next;
  229.            }
  230.       }
  231.       else {
  232.            prev=rove;
  233.            rove=rove->next;
  234.       }
  235.      }
  236. }
  237.  
  238.