开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
http_connect.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：62k
源码类别：

通讯编程

开发平台：

Visual C++

http_connect.c：源码内容
  1. /*
  2. http_connect
  4. Copyright July 5, 2001, The University of North Carolina at Chapel Hill
  6. Redistribution and use in source and binary forms, with or without
  7. modification, are permitted provided that the following conditions are met:
  9.   1. Redistributions of source code must retain the above copyright notice,
  10.      this list of conditions and the following disclaimer.
  11.   2. Redistributions in binary form must reproduce the above copyright
  12.      notice, this list of conditions and the following disclaimer in the
  13.      documentation and/or other materials provided with the distribution.
  14.   3. The name of the author may not be used to endorse or promote products
  15.      derived from this software without specific prior written permission.
  17. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18. WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19. MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  20. EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21. SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22. PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23. OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24. WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  25. OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  26. ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28. Contact person:
  30.     Frank D. Smith, University of North Carolina at Chapel Hill
  31.         email: smithfd@cs.unc.edu
  32. phone: 919-962-1884
  33. fax:   919-962-1799
  34. */
  36. /* 
  37.    This program performs an analysis of tcpdump output (the ASCII print
  38.    lines that tcpdump generates to stdout) and produces a summary of the
  39.    TCP connections used for HTTP.  It assumes that the tcpdump has been
  40.    filtered for packets that are from TCP source port 80 and that
  41.    the result has been sorted so that packets are in ascending time
  42.    order within each TCP connection.  The script given below will properly
  43.    prepare the input for this program given a tcpdump binary file that 
  44.    may contain more than just HTTP packets (the file extensions are
  45.    just examples, the program does not make any assumptions about input
  46.    file names).  Note that this filtering produces a UNI-DIRECTIONAL 
  47.    trace containing only those TCP segments sent from the server to the
  48.    client.
  50.    The output is a file with summary records for each connection (basically
  51.    the data data summarized into response and request lengths).  There is
  52.    also a <file name>.log file with summary counts.
  54.    To get usage information, invoke the program with the -h switch.
  56.    WARNING! THIS PROGRAM DEPENDS ON THE FORMAT OF THE OUTPUT OF TCPDUMP
  57.    AS PRINTED ON STDOUT (ASCII).  IT HAS BEEN TESTED ONLY ON THE 
  58.    FREEBSD VERSION OF TCPDUMP CORRESPONDING TO RELEASES UP THROUGH 4.1
  60.    KNOWN BUG: Does not process tcpdump output for ECN flags correctly.
  62. #! /bin/sh
  63. tcpdump -n -tt -r $1 tcp src port 80 > $1.http-srv
  64. sort -s -o $1.http-srv-sort +1 -2 +3 -4 +0 -1 -T /tmp $1.http-srv
  66. */
  68. #include <stdlib.h>
  69. #include <stdio.h>
  70. #include <math.h>
  71. #include <sys/time.h>
  73. #define min(a,b) ((a) <= (b) ? (a) : (b))
  74. #define max(a,b) ((a) >= (b) ? (a) : (b))
  76. int report_ACK_err = 1;
  78. void Usage(char *s)
  79. {
  80.   fprintf (stderr,"nUsage: %sn", s);
  81.   fprintf (stderr,"    [-w file_name] (name for output file)n");
  82.   fprintf (stderr,"    [-r file_name] (name for input file)n");
  83.   fprintf (stderr,"If either -w or -r is omitted, stdout(stdin) is usedn");
  84.   fprintf (stderr,"n");
  85.   exit(-1);
  86. }
  88.   FILE *dumpFP, *outFP;
  89.   FILE *logFP;
  91.   struct timeval recvTime;
  92.   struct timeval lastTime = {0,0};
  94.   char ts[20]; /* ASCII timestamp in tcpdump output */
  95.                /* max. ssssssssss.mmmmmm characters + EOL */
  96.   char sh[25]; /* ASCII source host.port in tcpdump output */
  97.                /* max. hhh.hhh.hhh.hhh.ppppp + EOL */
  98.   char gt[3];  /* ">" symbol in tcpdump output */
  99.   char lt[3];  /* "<" symbol in tcpdump output */
  100.   char dh[25]; /* ASCII destination host.port in tcpdump output */
  101.                /* max. hhh.hhh.hhh.hhh.ppppp + EOL */
  102.   char fl[5];  /* ASCII TCP flags field in tcpdump output */
  103.   char p1[50]; /* ASCII first field after flags in tcpdump output */
  104.   char p2[50]; /* ASCII second field after flags */
  105.   char p3[50]; /* ASCII third field after flags */
  107. /* These are read from the tcpdump records */
  108.   unsigned long begin_seq, end_seq, seq_bytes, new_ack;
  109.   unsigned long current_synseq;
  111.   int has_seq, has_ack;
  113. /* In TCP ACKs should be monotonically increasing so the length of the current
  114.    request in a sequence can be computed as the difference between the
  115.    ACK value marking the end of the previous request and the ACK value
  116.    marking the end of the current request.  Unfortunately, out-of-order
  117.    segments can cause ACKs to appear as if they "go backward".  For segments
  118.    without data (ACK_ONLY), simply ignoring the "backward" ACK is fine. 
  119.    In many cases where there is data along with a "backward" ACK,
  120.    this is the result of (un-necessary) retransmission of segments
  121.    containing data and those cases are handled properly.  In other cases,
  122.    the results can be incorrect for HTTP 1.1 connections.  Each case of
  123.    suspected ACK mis-ordering that might lead to erroneous request or
  124.    response lengths is noted for off-line investigation.
  125.    */
  127.   unsigned long current_request_end, last_request_end;
  129. /* In TCP segments the sequence numbers we see may NOT be monotonically
  130.    increasing (retransmission, out-of-order).  Instead we record the 
  131.    largest value seen at any point.  Then the length of the current
  132.    response in a sequence can be computed as the difference between the
  133.    (largest) sequence at the end of the previous response and the
  134.    (largest) sequence at the end of the current response.  */
  136.   unsigned long current_response_end, last_response_end;
  138. /* Various counters for logging connection summary information */
  140.   int syn_count = 0; /* connections beginning with SYN in trace */
  141.   int req_count = 0; /* number of identified requests */
  142.   int rsp_count = 0; /* number of identified responses */
  143.   int fin_count = 0; /* connections ending with FIN in trace */
  144.   int rst_count = 0; /* connections ending with Reset (no FIN) */
  145.   int trm_count = 0; /* connections ending with no Reset or FIN */
  146.   int err_count = 0; /* connections with at least one suspected error */
  147.   int act_req_count = 0; /* connections beginning in a request */
  148.   int act_rsp_count = 0; /* connections beginning in a response */
  149.   int pending_fin_count = 0; /* partial with only FIN(s) */
  150.   int pending_rst_count = 0; /* partial with only Reset(s) */
  151.   int pending_ack_count = 0; /* partial with only ACK(s) */
  152.   int pending_oth_count = 0; /* partial -- others */
  153.   int pending_cmb_count = 0; /* partials with FIN, Reset, ACK combinations */
  155. /* Various counters for events within a single connection */
  156.   /* the following apply only when state == PENDING; see pending_xxx_counts
  157.      above for explanations */
  158.   int have_pending_acks = 0;
  159.   int have_pending_fins = 0;
  160.   int have_pending_rsts = 0;
  161.   int have_pending_othr = 0;
  162.   /* the following apply only when state != PENDING */
  163.   int have_ACK_error = 0;   /* seen "backwards" ACK */
  164.   int have_value_error = 0; /* seen suspect ACK or sequence # */
  165.   int have_FINdata_error = 0; /* seen data after FIN */
  167.   enum states {PENDING, SYN_SENT, FIN_SENT, RESET, IN_REQUEST, IN_RESPONSE};
  169.   enum states connection_state = PENDING;
  170.   enum states last_state = PENDING;
  172.   enum inputs {SYN, FIN, RST, ACK_ONLY, DATA_ACK};
  173.   enum inputs input_type;
  175.   char current_src[25] = "";
  176.   char src_host[25];
  177.   char src_port[10];
  179.   char current_dst[25] = "";
  180.   char dst_host[25];
  181.   char dst_port[10];
  184. /* A request is considered to start at the timestamp on the tcpdump record
  185.    containing the first advance in the ACK field (a) following the connection
  186.    establishment or (b) while the connection is sending response data. */
  188.   char start_request_time[20];
  190. /* A response is considered to start at the timestamp on the tcpdump record
  191.    containing the first advance in the sequence number field following a
  192.    period when the ACK has been advanced (receiving request data).  */
  194.   char start_response_time[20];
  196. /* A response is considered to end at the timestamp on the tcpdump record 
  197.    that LAST advanced the data sequence number before the response ends 
  198.    (a new request starts, a FIN is sent, etc.).  Since we would have to
  199.    look ahead in the trace to be sure the current record has the LAST 
  200.    advance, we go ahead and assume it is the last and record its 
  201.    timestamp as response_end_time.  This way, when we know the sequence
  202.    number will not advance more for this response from processsing some 
  203.    subsequent record in the trace (FIN or ACK advance), the last timestamp
  204.    has already been saved.  Similarly, a request is considered to end at
  205.    the timestamp on the last record of the request. */
  206.   
  207.   char response_end_time[20];
  208.   char request_end_time[20];
  210.   char FIN_sent_time[20];   
  211.   char RST_sent_time[20];
  212.   char last_connection_time[20];
  214.   char input_name[256] = "";
  215.   char output_name[256] = "";
  216.   char log_name[256] = "";
  218.   char new_line[500];  /* assumes no tcpdump output line is longer */
  220.   long elapsed;
  222.   int new_address = 0;
  223.   int rc = 0;
  225. void error_line(char *s);  
  226. void error_state(char *s);
  227. int parse_dump_record(void);
  228. void init_connection(void);
  229. void init_active(void);
  230. void check_tuple_reuse(void);
  231. int check_ACK_advance(unsigned long old_ack);
  232. void begin_REQ(void);
  233. void more_REQ(void);
  234. void begin_RSP(void);
  235. void more_RSP(void);
  236. void log_REQ(void);
  237. void log_RSP(void);
  238. void log_SYN(void);
  239. void log_END(char *how);
  240. void log_ACT(char *how);
  241. void log_nosyn(void);
  242. void log_connection(void);
  243. void log_log(void);
  244. long elapsed_ms(char *end, char *start);
  245. void get_host_port(char *adr, char *host, char *port);
  246. int  get_sequence(char *p, unsigned long *begin, unsigned long *end,
  247.                            unsigned long *bytes);
  249. void main (int argc, char* argv[])
  250. {
  251.   int i;
  253.   /* Parse the command line */
  254.   i = 1;
  255.   while (i < argc) {
  256.     if (strcmp (argv[i], "-r") == 0) {
  257.       /* -r flag is followed by name of file to read */
  258.       if (++i >= argc) Usage (argv[0]);
  259.       strcpy (input_name, argv[i]);
  260.     }
  261.     else if (strcmp (argv[i], "-w") == 0) {
  262.       /* -w flag is followed by the name of file to write */
  263.       if (++i >= argc) Usage (argv[0]);
  264.       strcpy (output_name, argv[i]);
  265.     }
  266.     else 
  267.       Usage (argv[0]);
  268.     i++;
  269.   }
  271.   /* Open files */
  272.   /* Note: program is written to also be used as a filter */
  274.   if (strcmp(output_name, "") == 0) 
  275.     /* if no explicit output file named with -w, use stdout */
  276.      outFP = stdout;
  277.   else 
  278.      {
  279.       if ((outFP = fopen (output_name, "w")) == NULL) {
  280.           fprintf (stderr, "error opening %sn", output_name);
  281.           exit (-1);
  282.           }
  283.      }
  285.   if (strcmp(input_name, "") == 0)
  286.     /* if no explicit input file named with -r, use stdin */
  287.      dumpFP = stdin;
  288.   else 
  289.      {
  290.       if ((dumpFP = fopen (input_name, "r")) == NULL) {
  291.           fprintf (stderr, "error opening %sn", input_name);
  292.           exit (-1);
  293.          }
  294.      }
  295.   
  296.   strcpy(log_name, output_name);
  297.   strcat(log_name, ".log");
  298.   if ((logFP = fopen (log_name, "w")) == NULL) {
  299.       fprintf (stderr, "error opening %sn", log_name);
  300.       exit (-1);
  301.      }
  303.   /* begin main loop; once through loop for each line in the tcpdump */
  304.   /* a <continue> anywhere in the loop (usually after an error case)
  305.      implies beginning of processing a new tcpdump record */
  307.   while (!feof (dumpFP)) {
  309. /* printf("State is %d, last_state is %dn", connection_state, last_state); */
  311.     /* Get and parse line of tcpdump file */
  313.     fgets (new_line, sizeof(new_line), dumpFP);
  315.     /* get line pieces; this works because there are always 8 or more 
  316.        fields separated by white space in tcpdump ASCII-format lines */
  317. /*    sscanf (new_line, "%s %s %s %s %s %s %s %s %s",
  318.                       &ts, &lt, &sh, &gt, &dh, &fl, &p1, &p2, &p3);
  319. */
  320.     sscanf (new_line, "%s %s %s %s %s %s %s %s",
  321.                       &ts, &sh, &gt, &dh, &fl, &p1, &p2, &p3);
  323.    /* If any part of the connection tuple (source host.port,destination
  324.       host.port) differs from the current values, there are no more 
  325.       tcpdump records for that connection so treat as end of connection.
  326.       The action taken at the end of a connection depends on the current
  327.       state of processing in that connection */  
  329.    if ((strcmp(current_src, sh) != 0) ||  /* new source host/port */
  330.        (strcmp(current_dst, dh) != 0))    /* new dest. host/port */
  331.        {
  332.         log_connection(); 
  334.         /* begin processing this record as being from a potential new
  335.            TCP connection so initialize connection's state */
  337.         strcpy(current_src, sh);  /* new connection tuple */
  338.         strcpy(current_dst, dh);  /* host and port for src & dest */
  340.         have_pending_acks = 0;
  341.         have_pending_fins = 0;
  342.         have_pending_rsts = 0;
  343.         have_pending_othr = 0;
  345.         current_synseq = 0;
  346.         connection_state = PENDING;  /* unconnected pending a SYN */
  347.         last_state = PENDING;
  348.         new_address = 1;        /* true only for very first record
  349.                                    from a different TCP connection -- 
  350.                                    avoids multiple error messages */
  351.        }
  352.    
  353.    /* break dump record into essential data fields; initializes the
  354.       following variables: begin_seq, end_seq, seq_bytes, new_ack,
  355.                            has_ack, has_seq, input_type.
  356.       Also checks for suspect sequence and ACK values.
  357.    */
  359.    if ((rc = parse_dump_record()) < 0) 
  360.        continue;
  362.    /* processing records from a TCP connections is based on a notion of
  363.       the current "state" of the connection.  The defined states are
  364.         PENDING := record is from different connection than before but
  365.                    a beginning SYN has not yet been identified.
  366.         SYN_SENT:= have identified SYN sent from source port 80 (server)
  367.         FIN_SENT:= have identified a FIN sent from source port 80 (server)
  368.                    This terminates any data from server.
  369.         RESET   := have identified a Reset sent from source port 80 (server)
  370.                    This means that the server should not accept any more
  371.                    client data.
  372.         IN_REQUEST := processing ACKs sent from source port 80 (server)
  373.                       in response to data (request) from the client.  In
  374.                       this state, need to identify end of client data (request)
  375.                       and start of server data (response).
  376.         IN_RESPONSE := processing data sequence #s from source port 80
  377.                        In this state, need to identify the end of server data
  378.                        (response) and, possibly the beginning of a new request.
  379.       Whenever the state changes, the prior state is also noted.
  381.       Fundamental to all of this is the notion that a server cannot  
  382.       possibly be sending data in response to a request unless that
  383.       data is accompanied or preceeded by an advance in the ACK sequence
  384.       indicating receipt of the request data.  Similarly, we assume that
  385.       any new data sent by a server that follows or is accompanied by an
  386.       advance in the ACK sequence number is a response to the request 
  387.       that caused the ACK sequence to advance.  Put another way, response
  388.       data (sequence # advance) marks the end of a request and ACK 
  389.       advance marks the end of a response.  Of course other events such
  390.       as FIN or Reset can mark ends also.  The use of ACK advance to mark
  391.       the end of a response assumes that HTTP/1.1 browsers don't overlap 
  392.       requests on a single TCP connection even if they may "batch" requests, 
  393.       i.e., a new request will not be generated until the response has 
  394.       been received. If requests and responses are batched but not 
  395.       overlapped this will understate the number of objects requested 
  396.       and overstate request and response sizes.
  398.       This use of advancing sequence numbers (ACK or data) to mark
  399.       requests and responses is disturbed by segment reorderings in 
  400.       the network.  In some cases, such as reordering of only data segments
  401.       in a response, there is no problem since only the highest value seen
  402.       is used.  Reordering of ACKs (especially with data) presents real
  403.       problems since boundaries between requests and responses are missed
  404.       which can result in overstating request and response sizes.  For this
  405.       reason, all such cases of ACK misordering are logged and reported.
  406.    */
  408.    switch (connection_state)
  410.      /* a <break> anywhere ends processing of the current tcpdump record 
  411.         by ending the switch (which continues the main read loop) */
  413.       {
  414.        case PENDING:
  415.  {
  416.           switch (input_type)
  417.              {
  418.      case FIN:
  419.         {
  420.  /* Ignore random FIN before something useful */ 
  422.                  have_pending_fins++;
  423.                  break;
  424.                 }
  426.      case SYN:
  427.         {
  428.   /* normal connection start, initialize connection state */
  430.                  init_connection();
  431.                  break;
  432. }
  434.      case RST:
  435.                 {
  436.   /* Ignore random Reset before something useful */
  438.                  have_pending_rsts++;
  439.                  break;
  440.                 }
  442.              /* The trace may start after a connection is established and we
  443.                 do not see a SYN.  Determine if the connection is most likely
  444.                 in a request or in a response and log its status.  As before,
  445.                 a request is indicated if the ACK sequence (after the first
  446.                 one in the trace) is advancing and a response is indicated if
  447.                 the data sequence number is advancing. */
  449.              case ACK_ONLY:
  450.         {
  451.                   /* ignore initial ACK (has absolute value, not relative) */
  453.                  if (new_address == 1)
  454.    {
  455.                     new_address = 0;
  456.                     have_pending_acks++;
  457.                    }
  458.                  else
  459.     {
  460.      /* If ACK advances, the connection is in a request */
  462.                      if ((new_ack > 2) &&
  463.                          (new_ack < 16384))
  464.         {
  465.                          log_ACT("REQ");
  467.                          last_request_end = 1;
  468.                          current_request_end = new_ack;
  470.                          last_response_end = 1;
  471.                          current_response_end = 1;
  473.                        /* record the request start time as beginning at the 
  474.                           tcpdump time stamp on this record */
  476.                           strcpy(start_request_time, ts);
  477.                           strcpy(request_end_time, ts);
  479.                           last_state = connection_state;
  480.                           connection_state = IN_REQUEST;
  481.  
  482.                           init_active();  /* initialize connection state */
  483.  }
  484.                      else /* ignore ACKs that are not advancing */
  485.                         have_pending_acks++;
  486.     }
  487.                  break;
  488.                 }
  490.      case DATA_ACK:          
  491.         {
  492.  /* If data sequence advances, connection is in response */
  494.                  if ((seq_bytes > 1) &&
  495.                      (seq_bytes < 65535))
  496.     {
  497.                      log_ACT("RSP");
  499.                      /* assume tcpdump relative addressing and initialize */
  501.                      last_request_end = 1;    
  502.                      current_request_end = 1;
  504.                      last_response_end = 0;     
  505.                      current_response_end = seq_bytes;
  507.                      /* record timestamp of tcpdump record as current
  508.                         value of both start and end times of response
  509.                         (in case no later end time is found) */
  511.                      strcpy(start_response_time, ts); 
  512.                      strcpy(response_end_time, ts);
  514.                      last_state = connection_state;
  515.                      connection_state = IN_RESPONSE;
  516.  
  517.                      init_active();
  518.                     }
  519.                  else /* ignore data lengths of 0 or 1 */
  520.                     have_pending_othr++;
  521.                  break;
  522.                 }
  523.      default:
  524.                 break;
  525.              }  /* end switch on input_type */
  526.           break;
  527.  } /* end case PENDING */
  529.        case SYN_SENT:
  530.          {
  532.          /* Treat this case as the establishment of a connection.  Usually
  533.             the first activity on the connection will be request data from
  534.             the client, but some servers appear to "pre-send" data (maybe
  535.             the headers) speculatively before ACKing any client data. */
  537.           switch (input_type)
  538.              {
  539.      case FIN:
  541.               /* A FIN marks the end of either or both request and response */
  543.         {
  544.                  if ((has_ack == 1) &&
  545.                      (new_ack > (current_request_end + 1)))
  546.                                /* ignore possible ACK of FIN */
  548.            { /* this record had advanced the ACK sequence so
  549.                         save current request data and log it (since
  550.                         the FIN ends the connection it also ends the 
  551.                         request). */
  552.                
  553.                      begin_REQ();
  554.                      log_REQ();
  555.                     }
  557.                  /* If the data sequence number advances, then there was
  558.                     response data.  Save the current response info. and
  559.                     log it (since the FIN ends the connection, it also
  560.                     ends the response). */
  562.                  if ((has_seq == 1) &&
  563.                      (end_seq > current_response_end))  
  564.     {
  565.                      begin_RSP();
  566.                      log_RSP();
  567.                     }
  568.                  last_state = SYN_SENT;
  569.                  connection_state = FIN_SENT;
  571.                  /* record timestamp of first FIN seen on connection */
  572.                  if (strcmp(FIN_sent_time, "") == 0)
  573.                     strcpy(FIN_sent_time, ts);
  574.                  break;
  575.                 }
  577.      case SYN:
  578.         {
  579.   /* In some cases the same host/port pairs are reused in a
  580.                      single trace; check for plausible reuse */
  582.                  check_tuple_reuse();
  583.                  break;
  584. }
  586.      case RST:
  587.                 {
  588.                  connection_state = RESET;
  589.                  last_state = SYN_SENT;
  591.                  /* record timestamp of first Reset on the connection */
  593.                  if (strcmp(RST_sent_time, "") == 0)
  594.                     strcpy(RST_sent_time, ts);
  595.                  break;
  596.                 }
  598.              case ACK_ONLY:
  599.         {
  600.                  /* since there is no data sequence # present in the record
  601.                     and, therefore, the server is not sending data so
  602.                     all the client's data may not have arrived.  Note the
  603.                     current extent of ACKed client data and change state */
  605.                  if (new_ack > (current_request_end + 1))
  606.                     begin_REQ();
  607.                  break;
  608.                 }
  610.      case DATA_ACK:          
  611.         {
  612.                 /* check for presence of data sequence # in the common cases
  613.                    in SYN_SENT state, data presence indicates that 
  614.                    request data has been received and server is sending data
  615.                    that should be a response */
  617.                  if (new_ack > (current_request_end + 1)) 
  618.              {/* this record had advanced the ACK sequence so
  619.                      save current request info. and change state */
  621.                      begin_REQ();
  623.                      /* the server's data sequence may not have advanced;
  624.                         but if it has, treat it as the start of a response
  625.                         and the end of the client (request) data */
  627.                      if (end_seq > current_response_end)
  628.         {
  629.                           /* start of response ends the request, log
  630.                           it and change state to look for end of response */  
  632.                          log_REQ();
  633.                          begin_RSP();
  634.         }
  635.     }
  636.                  else 
  637.    /* some servers appear to send response data immediately
  638.                       on completing the TCP connection without receiving 
  639.                       any request data */
  641.                     if ((end_seq > last_response_end) && 
  642.                         (seq_bytes > 0))
  643.                        begin_RSP();
  644.                 break;
  645. }
  646.      default:
  647.                 break;
  648.      } /* end switch on input type */
  649.           break;
  650.  } /* end case SYN_SENT */
  652.        case FIN_SENT:
  653.   {
  654.            switch (input_type)
  655.               {
  656.        case SYN:
  657.           {
  658.   /* In some cases the same host/port pairs are reused in a
  659.                      single trace; check for plausible reuse */
  661.                    check_tuple_reuse();
  662.                    break;
  663.   }
  665.         case FIN:  /* ignore multiple FINs */
  666.                    break;
  668.                 case RST:  /* ignore reset after FIN */
  669.                    break;
  671.         case ACK_ONLY:
  672.                     /* If there is an ACK (only) coming after a FIN is sent, it
  673.                       is ether the normal one in the 4-way termination or it
  674.                       is to ACK more request data which will be ignored (there
  675.                       can be no response).  
  676.                       In either case, it is ignored here. */
  678.                    break;
  680.         case DATA_ACK:
  681.   {
  683.               /* All others may have sequence number fields.  Treat them as
  684.                  errors if they advance the sequence number after a FIN.  
  685.                  The usual case here is just retransmissions (including 
  686.                  retransmission of the FIN) which should not advance it
  687.                  because the highest sequence number possible was on the FIN */
  689.                    if ((end_seq > (current_response_end + 2)) &&
  690.                        (have_FINdata_error == 0))
  691.       {
  692.                        error_state("new data in FIN_SENT state");
  693.                        have_FINdata_error = 1;
  694.                       }
  695.                    break;
  696.   }
  697.         default:
  698.                    break;
  699.       } /* end switch on input type */
  700.             break; 
  701.   } /* end case FIN_SENT */
  703.        case RESET:
  704.    {
  705.     /* A Reset nominally means an abnormal close of the connection 
  706.                with any queued data discarded before transmitting it.  We
  707.                observe, however, that under some (unknown) circumstances
  708.                segments that advance the data sequence number continue in 
  709.                the trace after the Reset.  If these are part of a response, 
  710.                it makes sense to count them in the response size since 
  711.                the server obviously sent them and the network has to handle 
  712.                them.  This also means that a FIN following the Reset may be
  713.                a valid indication of the end of a response. Just ignore 
  714.                anything else unexpected (e.g., Reset) */
  716.             switch (input_type)
  717.                {
  718.         case RST:
  719.                    break;
  721.         case SYN:
  722.           {
  723.   /* In some cases the same host/port pairs are reused in a
  724.                      single trace; check for plausible reuse */
  726.                    check_tuple_reuse();
  727.                    break;
  728.   }
  730.         case ACK_ONLY:
  732.                /* an ACK might advance possibly indicating a request.  However,
  733.                   since the connection is Reset and there should be no new
  734.                   response, just ignore it */
  736.                     break;
  738.         case FIN:
  739.   {
  741.             /* Only if the state is IN_RESPONSE do we try to continue looking
  742.                for the end of the response.  FIN is treated as the true end
  743.                of a response. */
  745.                    if (last_state == IN_RESPONSE)
  746.                {/* ends the current response, ignore any ACK */
  747.                        if ((has_seq == 1) &&
  748.                            (end_seq > current_response_end)) 
  749.                           more_RSP();
  750.                        log_RSP();
  751.   
  752.                        last_state = RESET;
  753.                        connection_state = FIN_SENT;
  755.                        /* record timestamp of first FIN on connection */
  757.                        if (strcmp(FIN_sent_time, "") == 0)
  758.                           strcpy(FIN_sent_time, ts);
  759.       }
  760.                     break;
  761.    }
  763.        case DATA_ACK:
  764.                  {
  765.                 /* segments with data may advance the data sequence number as 
  766.                    more parts of the response.  They may also advance the ACK
  767.                    which normally would indicate a new request.  However,
  768.                    after a Reset, it probably will be ignored by the 
  769.                    server so it is also ignored here except to mark the end
  770.                    of the response. */
  772.                    if (last_state == IN_RESPONSE)
  773.       {
  774.                        if (new_ack > (last_request_end + 1)) /* new request */
  775.                           { /* implies end of current response */
  776.                            log_RSP(); 
  777.                            last_state = RESET; /* will ignore all else */
  778.                            break; 
  779.                           }
  780.  
  781.                      /* As long as the data sequence # advances, continue to
  782.                         save info about the current response. */
  784.                        if ((end_seq > current_response_end) &&
  785.                            (seq_bytes > 0))
  786.                           more_RSP();
  787.                       }
  788.                   break;
  789.  }
  790.                default:
  791.                   break;
  792.        } /* end switch on input type */
  793.             break;
  794.            } /* end case RESET */
  796.        case IN_RESPONSE:
  797.    {
  798.             /* In this state, look for events that will indicate the end of
  799.                the response data (ACK advances for request, FIN, Reset).  If
  800.                the event is ACK advance, this also initiates the start of a
  801.                new request.  */
  803.             switch (input_type)
  804.                {
  805.         case FIN:
  806.   {         
  807.                    /* FIN is complicated since the segment that carries it may
  808.                     also advance the ACK (new request), advance the data
  809.                     sequence # and end the connection.  If the ACK advances,
  810.                     any sequence # advance is for the new request; otherwise
  811.                     a sequence # advance extends and completes the current 
  812.                     response. */
  814.                    if (has_ack == 1) 
  815.       {
  816.        if ((rc = check_ACK_advance(current_request_end)) < 0)
  817.                           break;
  818.                       }
  820.    /* The ACK advance amount has to be greater than 1 to be
  821.                      considered a real new request.  This is primarily to
  822.                     filter out just an ACK for a FIN from the client.  Note
  823.                     the ACK must advance so duplicate ACKs are ignored. */
  825.                    if ((has_ack == 1) &&
  826.                        (new_ack > (current_request_end + 1)))
  827.                      { /* implies end of current response, begin request 
  828.                            Log the info. for the current response. */
  830.                        log_RSP();  /*end of previous response */
  832.                        /* on FIN, assume end of request also since server is
  833.                           closing the connection. */
  835.                        begin_REQ();
  836.                        log_REQ(); 
  838.                        /* if the data sequence # also advances, this segment
  839.                           (only -- because of the FIN) carries the last part
  840.                           of the response */
  841.  
  842.                        if ((has_seq == 1) &&
  843.                            (end_seq > last_response_end)) 
  844.                           {/* response begins and ends in the FIN segment */
  845.                            begin_RSP();
  846.                            log_RSP();  /* also end of any response */
  847.                           }
  849.                        /* Note that the null "else" here is the case that the
  850.                           data sequence # does not advance (there is no 
  851.                           response to the request) -- probably an HTTP/1.1
  852.                           broswer attempting multiple requests on a TCP 
  853.                           connection where the server doesn't play nice. */
  855.                       }
  856.                    else 
  857.                       /* the ACK did not advance so no request; if the data
  858.                        sequence # advances, it extends the current response */
  860.       {
  861.                        if ((has_seq == 1) &&
  862.                            (end_seq > current_response_end)) 
  863.                           more_RSP();
  864.                        log_RSP();    /* FIN always implies end of response */
  865.                       }
  867.                    last_state = IN_RESPONSE;
  868.                    connection_state = FIN_SENT;
  870.                    if (strcmp(FIN_sent_time, "") == 0)
  871.                       strcpy(FIN_sent_time, ts);
  872.                    break;
  873.   }
  875.                case RST:
  877.                  /* Look for a Reset and only change state to RESET to
  878.                    continue processing.  This is explained in comments in 
  879.                    processing for the RESET state when the last_state is
  880.                    IN_RESPONSE. */
  882.            {/* ignore any advance in seq# on Reset */
  883.                   /* it may not be wise to trust ACK on RST */
  885.                   last_state = IN_RESPONSE;
  886.                   connection_state = RESET;   
  888.                   if (strcmp(RST_sent_time, "") == 0)
  889.                      strcpy(RST_sent_time, ts);
  890.                   break;
  891.                  }
  893.                case SYN:
  894.            {
  895.   /* In some cases the same host/port pairs are reused in a
  896.                      single trace; check for plausible reuse */
  898.                   check_tuple_reuse();
  899.                   break;
  900.  }
  902.                case ACK_ONLY:
  904.             /* Begin checking for cases where the ACK may advance
  905.                     and really indicate that a new request starts. */
  907.                  {
  908.     /* The ACK advance amount has to be greater than 1 to be
  909.                      considered a real new request.  This is primarily to
  910.                      filter out just an ACK for a FIN from the client.  Note
  911.                      the ACK must advance so duplicate or OOO
  912.                      ACKs are ignored. */
  914.                   if (new_ack > (last_request_end + 1)) 
  915.      { /* implies end of current response, begin request.
  916.                          Log the info. for the current response and change
  917.                          states. */
  918.                       log_RSP();
  920.                     /* since there is no data sequence # present in the record
  921.                     and, therefore, the server is not sending data so
  922.                     all the client's data may not have arrived.  Note the
  923.                     current extent of ACKed client data and start time */
  925.                       begin_REQ();
  926.                      }
  927.                   break;
  928.                  }
  930.                case DATA_ACK:
  932.             /* cases with data and ACKs have two important sub-cases: (a) 
  933.                ACK sequence number advances -- implies the start of a
  934.                new request and the end of the current response; if the
  935.                data sequence number also advances, it is assumed that
  936.                all the request data has been received and the first of
  937.                the response data is contained in the segment. (b) the
  938.                ACK sequence number does not advance so any advance in
  939.                the data sequence number is more of the current response. */
  941.        {
  942. if ((rc = check_ACK_advance(last_request_end)) < 0)
  943.                    break;
  945.  /* The ACK advance amount has to be greater than 1 to be
  946.                     considered a real new request.  This is primarily to
  947.                     filter out just an ACK for a FIN from the client.  Note
  948.                     the ACK must advance so duplicate ACKs are ignored. */
  950.                 if (new_ack > (last_request_end + 1)) 
  951.            { /* implies end of current response, begin request 
  952.                          Log the info. for the current response. */
  954.                     log_RSP();  
  955.                     begin_REQ();
  957.                     /* If there is also new data (sequence # advances), then
  958.                        the request is considered completed and a new response
  959.                        has started but not necessarily completed. */
  961.                     if ((end_seq > current_response_end) &&
  962.                         (seq_bytes > 0))
  963.        {/* Log info. about this request */
  964.                         log_REQ();
  965.                         begin_RSP();
  966.        }
  967.    }
  968.                 else
  969.                     /* the ACK did not advance so no request; if the data
  970.                        sequence # advances, it extends the current response */
  972.                     if (end_seq > current_response_end) 
  973.                        more_RSP();
  974.                 break;
  975.                }
  976.      default:
  977.                 break;
  978.     } /* end switch on input type */
  979.            break;
  980.   }  /* end case IN_RESPONSE */
  982.        case IN_REQUEST:
  983.    {
  984.     /* In this state check for events that indicate the end of the
  985.                request data (advance of data sequence #, FIN, Reset).  An
  986.                advance in the data sequence # also marks the beginning of
  987.                the response to the request */
  989.             switch (input_type)
  990.                {
  991.         case FIN:
  993.             /* FIN is somewhat less complicated here since the segment that
  994.                implies that the server will send no more data.  Treat this
  995.                as effectively ending the request.  If the ACK advances, it
  996.                is considered as part of the request and if the data 
  997.                sequence # advances, it is the response data (all in this
  998.                segment). */
  1000.         { /* FIN can ACK more of current request */
  1002.   /* The ACK advance amount has to be greater than 1 to be
  1003.                     considered as extending the request.  This is primarily 
  1004.                     to filter out just an ACK for a FIN from the client.  Note
  1005.                     the ACK must advance so duplicate ACKs are ignored. */
  1007.                  if ((has_ack == 1) &&
  1008.                      (new_ack > (current_request_end + 1)))
  1009.                     more_REQ();
  1010.                  else
  1011.                     if (has_ack == 1)
  1012.        {
  1013.         if ((rc = check_ACK_advance(current_request_end)) < 0)
  1014.                            break;
  1015.                        }
  1017.                  log_REQ();  /* on FIN, assume end of request */
  1019.                 /* the server's data sequence may not have advanced;
  1020.                    but if it has, treat it as the complete response */
  1022.                  if ((has_seq == 1) &&
  1023.                      (end_seq > last_response_end))  
  1024.                     {
  1025.                      begin_RSP();
  1026.                      log_RSP();  /* also end of any response */
  1027.                     }
  1029.                  last_state = IN_REQUEST;
  1030.                  connection_state = FIN_SENT;
  1032.                  if (strcmp(FIN_sent_time, "") == 0)
  1033.                     strcpy(FIN_sent_time, ts);
  1034.                  break;
  1035. }
  1037.      case RST:
  1038.                {
  1039.                 /* Treat a Reset as ending the request with no response */
  1040.         /* ignore any advance in ack on Reset */
  1041. /* treat as ending any request */
  1043.                 log_REQ();                
  1044.                 last_state = IN_REQUEST;
  1045.                 connection_state = RESET;
  1047.                 if (strcmp(RST_sent_time, "") == 0)
  1048.                    strcpy(RST_sent_time, ts);
  1049.                 break;
  1050.        }
  1052.      case SYN:
  1053.         {
  1054.  /* In some cases the same host/port pairs are reused in a
  1055.                     single trace; check for plausible reuse */
  1057.                  check_tuple_reuse();
  1058.                  break;
  1059. }
  1061.      case ACK_ONLY:
  1062.         {
  1063.  /* The ACK advance amount has to be greater than 1 to be
  1064.                     considered as extending the requesst.  This is primarily 
  1065.                     to filter out just an ACK for a FIN from the client.  Note
  1066.                     the ACK must advance so duplicate or OOO 
  1067.                     ACKs are ignored. */
  1069.                  if (new_ack > (current_request_end + 1))
  1070.                     more_REQ();
  1071.                  break;
  1072.                 }
  1074.      case DATA_ACK:
  1075.                {
  1076.                 /* cases with data and ACKs have two important sub-cases: 
  1077.                   (a) ACK sequence number advances which extends the amount
  1078.                   of request data, and (b) the data sequence # advances
  1079.                   which ends the request and is the beginning of the 
  1080.                   response to that request. */
  1081. /* The ACK advance amount has to be greater than 1 to be
  1082.                    considered as extending the request.  This is primarily 
  1083.                    to filter out just an ACK for a FIN from the client.  Note
  1084.                    the ACK must advance so duplicate ACKs are ignored. */
  1086.                 if (new_ack > (current_request_end + 1))
  1087.                    more_REQ();
  1088.                 else
  1089.     if ((rc = check_ACK_advance(current_request_end)) < 0)
  1090.                        break;
  1092.                 /* the server's data sequence may not have advanced;
  1093.                    but if it has, treat it as the start of a response
  1094.                    and the end of the request data */
  1096.                 if ((end_seq > last_response_end) && 
  1097.                     (seq_bytes > 0))
  1098.                    {
  1099.     /* record info. for current request and change state 
  1100.                        to look for the end of the response*/
  1102.                     log_REQ();
  1103.                     begin_RSP();
  1104.                    }
  1105.                 break;
  1106.                }
  1107.      default:
  1108.                 break;
  1109.     } /* end switch on input type */ 
  1110.           break;
  1111.  }  /* end case IN_REQUEST */
  1113.        default:
  1114.        break;
  1115.       } /* end switch on connection state */
  1117.    /* save the last known time for the connection from current record */
  1118.    strcpy(last_connection_time, ts); 
  1120.  }  /* end main loop */  
  1121.   log_log();
  1122.   close (dumpFP);
  1123.   close (outFP);
  1124.   close (logFP);
  1125. } /* end main() */
  1128. /* Initialize connection state when a new connection is recognized by
  1129.    the presence of a SYN. */ 
  1131. void init_connection(void)
  1132. {
  1133.  log_SYN();                /* log start of connection */
  1134.  connection_state = SYN_SENT;  /* new connection state */
  1136.  /* save SYN sequence number for duplicate detection */
  1137.  if (has_seq == 1)
  1138.      current_synseq = begin_seq;
  1139.  else
  1140.      error_line ("SYN without valid sequence #");
  1142.  /* assume tcpdump relative addressing and initialize */
  1143.  /* note that initializing to 1 instead of 0 adjusts for ACK
  1144.     being the next expected sequence number */
  1146.  last_request_end = 1;       /* need "last" and "current" */
  1147.  last_response_end = 1;      /* values since there may be */
  1148.  current_response_end = 1;   /* > 1 request per connection */
  1149.  current_request_end = 1;
  1151.  strcpy(FIN_sent_time, "");
  1152.  strcpy(RST_sent_time, "");
  1153.  strcpy(last_connection_time, "");
  1155.  have_ACK_error = 0;
  1156.  have_value_error = 0;
  1157.  have_FINdata_error = 0;
  1158. }
  1160. /* Initialize connection state when a new connection is recognized by a
  1161.    change in the host/port 4-tuple, there is no SYN but request or 
  1162.    response activity can be determined.  Request or response state is
  1163.    initialized in the main program when the type of activity is determined */ 
  1165. void init_active(void)
  1166. {
  1167.  strcpy(FIN_sent_time, "");
  1168.  strcpy(RST_sent_time, "");
  1169.  strcpy(last_connection_time, "");
  1171.  have_ACK_error = 0;
  1172.  have_value_error = 0;
  1173.  have_FINdata_error = 0;
  1175. }
  1177. /* Check for some indications of possible errors 
  1178.    such as the ACK appearing to move back -- may indicate
  1179.    out-of-order or something worse. */
  1181. int check_ACK_advance(unsigned long old_ack)
  1182. {
  1183.  
  1184.  if ((new_ack < old_ack) &&
  1185.       report_ACK_err)
  1186.     {
  1187.      if (have_ACK_error == 0)
  1188.         {
  1189.          error_state("ACK error -- backward");
  1190.          have_ACK_error = 1;
  1191.         }
  1192.      return(-1);
  1193.     }
  1194.  else
  1195.     return (0);
  1196. }
  1198. /* Check to see if reuse of a connection in a trace is reasonable */
  1200. void check_tuple_reuse(void)
  1201. {
  1202.  /* ignore duplicate SYNs (have same SYN sequence number) */
  1204.  if ((has_seq == 1) &&
  1205.      (current_synseq != begin_seq))
  1206.     {
  1207.       /* if a non-duplicate SYN comes before any other activity,
  1208.          treat it as terminating the incomplete connection and starting
  1209.          another */
  1210.      
  1211.      if ((connection_state == SYN_SENT) ||
  1212.          ((connection_state == RESET) && (last_state == SYN_SENT)))
  1213.         {
  1214.          log_END("TRM");
  1215.          init_connection();
  1216.          return;
  1217.         }
  1220.     /* It is quite possible to have a valid new
  1221.     connection that reuses the same source and destination
  1222.     IP.port address 4-tuple.  Treat this as valid if 
  1223.     there has been a FIN from the server or at least
  1224.     2*MSL has passed since seeing any previous packet
  1225.     from this connection (in case we missed the FIN).  If there
  1226.     was a FIN from the server, allow for the case it was an
  1227.     active close by the server (normal for HTTP 1.0), the 
  1228.     stack is a BSD derivative, and SO_REUSEADDR is is use
  1229.     (see Stevens vol. 1, pp 245) */ 
  1231.      if (connection_state == FIN_SENT)
  1232.         elapsed = 60001;  /* force beyond 2MSL test */
  1233.      else        
  1234.         elapsed = elapsed_ms(ts, last_connection_time);
  1236.      if (elapsed < 60000)  /* MSL of 30 seconds, minimum */
  1237.         error_state("Non-duplicate SYN in connection");
  1238.      else
  1239. {
  1240.  /* perform all actions associated with the end of
  1241.             one connection and the beginning of the next 
  1242.             (see state PENDING) */
  1243.          switch (connection_state)
  1244.     {
  1245.     case FIN_SENT:
  1246.                  log_END("FIN");
  1247.                  break;
  1248.             case RESET:
  1249.                  if (last_state == IN_RESPONSE)
  1250.                     log_RSP();
  1252.                  log_END("RST");
  1253.                  break;
  1254.             case IN_RESPONSE:
  1255.                  log_RSP();
  1256.                  log_END("TRM");
  1257.                  break;
  1258.             case IN_REQUEST:
  1259.                  log_REQ();
  1260.                  log_END("TRM");
  1261.                  break;
  1262.             default:
  1263.                  break;
  1264.     }
  1265.          init_connection();
  1266.         }
  1267.     }
  1268. }
  1270. /* Record information about the beginning of a new request */
  1272. void begin_REQ(void)
  1273. {
  1274.  current_request_end = new_ack;
  1276.  /* record the request start time as beginning at the 
  1277.     tcpdump time stamp on this record */
  1279.  strcpy(start_request_time, ts);
  1280.  strcpy(request_end_time, ts);
  1282.  last_state = connection_state;
  1283.  connection_state = IN_REQUEST;
  1284. }
  1286. /* Record information about an in-progress request */
  1288. void more_REQ(void)
  1289. {
  1290.  current_request_end = new_ack;
  1291.  strcpy(request_end_time, ts);
  1292. }
  1294. /* Record information about the beginning of a new response */
  1296. void begin_RSP(void)
  1297. {
  1298.  current_response_end = end_seq;
  1300.  /* record timestamp of tcpdump record as current
  1301.  value of both start and end times of response
  1302.  (in case no later end time is found) */
  1304.  strcpy(start_response_time, ts); 
  1305.  strcpy(response_end_time, ts);
  1307.  last_state = connection_state;
  1308.  connection_state = IN_RESPONSE;
  1309. }
  1311. /* Record information about an in-progress response */
  1313. void more_RSP(void)
  1314. {
  1315.  current_response_end = end_seq;
  1316.  /* save the new (potential) response end time */
  1317.  strcpy(response_end_time, ts);
  1318. }
  1321. /* Breaks dump record into essential data fields; initializes the
  1322.    following variables: begin_seq, end_seq, seq_bytes, new_ack,
  1323.                         has_ack, has_seq, input_type.
  1324.    Also checks for suspect sequence and ACK values.
  1325. */
  1327. int parse_dump_record()
  1328. {
  1329.     begin_seq = end_seq = seq_bytes = new_ack = 0;
  1330.     has_ack = has_seq = 0;
  1332.    /* The following flag combinations are flagged because they (a) make no
  1333.       real sense for SYNs and (b) should be very rare. */
  1335.     if ((strcmp(fl, "SFRP") == 0) ||
  1336. (strcmp(fl, "SFR") == 0) ||
  1337. (strcmp(fl, "SFP") == 0) ||
  1338. (strcmp(fl, "SF") == 0) ||
  1339. (strcmp(fl, "SRP") == 0) ||
  1340. (strcmp(fl, "SR") == 0))
  1341.        {
  1342.  /* If out of PENDING state (initial SYN recognized), just note
  1343.             the error, ignore it and continue.  */
  1345.         if (connection_state != PENDING)
  1346.             error_line ("SYN in combination with F or R");
  1347.         return(-1);
  1348.        }
  1350.     /* In tcpdump format, the fields coming after flags are, in order,
  1351.        data-seqno (format "bbb:eee(ccc)") and ack (format "ack xxx").
  1352.        Both the data-seqno and ack fields may not be present if they
  1353.        do not have valid information.  If the data-seqno field is not
  1354.        present, the first field after the flag is the string "ack";
  1355.        if both are not present the field after the flag is the 
  1356.        string "win".  Also check to see if tcpdump used absolute instead
  1357.        of relative values */
  1359.     if (strcmp(p1, "ack") == 0)  /* ack and no data sequence no. */
  1360.        {
  1361.         has_seq = 0;
  1362.         has_ack = 1; 
  1363.         new_ack = strtoul(p2, (char **)NULL, 10);
  1364.        }
  1365.     else
  1366.        {
  1367.         if (strcmp(p1, "win") == 0) /* no ack, no data */
  1368.    {
  1369.             has_ack = 0;
  1370.             has_seq = 0;
  1371.            }
  1372.         else 
  1373.    {
  1374.             /* assume it is a valid sequence number field */
  1375.     /* parse sequence field in header */
  1376.     /* sequence field format is
  1377.                <begin_seq #>:<end_seq #>(<seq_bytes count>) */
  1379.             if ((rc = get_sequence(p1, &begin_seq, &end_seq, &seq_bytes)) < 0)
  1380.        {
  1381.                 error_line ("invalid sequence # field");
  1382.                 return (-1);
  1383.                }
  1384.             has_seq = 1;
  1386.             /* check the field following the data sequence # for an ACK */
  1388.             if (strcmp(p2, "ack") == 0)  
  1389.                {
  1390.                 has_ack = 1; 
  1391.                 new_ack = strtoul(p3, (char **)NULL, 10);
  1392.                }
  1393.             else
  1394.                has_ack = 0;
  1395.            }
  1396.        }
  1398.    /* classify flag combinations into equivalence classes for later steps */
  1400.       if ((strcmp(fl, "F") == 0) || 
  1401.           (strcmp(fl, "FP") == 0) ||
  1402.           (strcmp(fl, "FR") == 0) ||
  1403.           (strcmp(fl, "FRP") == 0))
  1404.          input_type = FIN;
  1405.       else
  1406.  {
  1407.           if ((strcmp(fl, "R") == 0) ||
  1408.               (strcmp(fl, "RP") == 0))
  1409.              input_type = RST;
  1410.           else
  1411.      {
  1412.               if ((strcmp(fl, "S") == 0) || 
  1413.                   (strcmp(fl, "SP") == 0))
  1414.                  input_type = SYN;
  1415.               else
  1416.                 {
  1417.                  if ((has_ack == 1) &&
  1418.                      (has_seq == 0))
  1419.                     input_type = ACK_ONLY;
  1420.                  else
  1421.                     if ((has_seq == 1) &&
  1422.                         (has_ack == 1))
  1423.                        input_type = DATA_ACK;
  1424.                     else
  1425.        {   
  1426.                         error_line("Unexpected Data/ACK combination");
  1427.                         return (-1);
  1428.                        }
  1429. }
  1430.      }
  1431.  }
  1434.       if ((connection_state == IN_RESPONSE) ||
  1435.           (connection_state == IN_REQUEST) ||
  1436.           (connection_state == SYN_SENT) ||
  1437.           ((connection_state == RESET) && (last_state == IN_RESPONSE)))
  1438.  {   
  1439.    /* allow for gaps of up to one normal TCP window */
  1441.           if (((input_type == FIN) ||
  1442.                (input_type == DATA_ACK)) &&
  1443.                (end_seq > (current_response_end + 65535)))
  1444.      {
  1445.               if (have_value_error == 0)
  1446.  {
  1447.                   error_line ("suspect sequence # value");
  1448.                   have_value_error = 1;
  1449.                  }
  1450.               return (-1);
  1451.              }
  1453.           /* ACK is required for each 2 segments with space for gaps */
  1455.           if (((input_type == FIN) ||
  1456.                (input_type == ACK_ONLY) ||
  1457.                (input_type == DATA_ACK)) &&
  1458.                (new_ack > (current_request_end + 16384)))
  1459.      {
  1460.               if (have_value_error == 0)
  1461.  {
  1462.                   error_line ("suspect ACK value");
  1463.                   have_value_error = 1;
  1464.                  }
  1465.               return (-1);
  1466.              }
  1467.          }
  1468.  return(0);
  1469. }
  1471. /* Output data associated with ending a connection */
  1473. void log_connection(void)
  1474. {
  1475. /* if no more tcpdump records found while processing an http
  1476.    request, log (perhaps incomplete) client request */  
  1478.    if (connection_state == IN_REQUEST)
  1479.       log_REQ();
  1480.    else
  1481.       {
  1482.        /* if no more records found while processing an http 
  1483.           response, log (perhaps incomplete) response information */
  1485.        if ((connection_state == IN_RESPONSE) ||
  1486.            ((connection_state == RESET) && last_state == IN_RESPONSE))
  1487.   { /* don't log if just ACKed 1 (assume  FIN) */
  1488.            if (current_response_end > (last_response_end + 1))
  1489.                log_RSP();
  1490.           }
  1491.       }
  1493.    /* make log entry indicating type of connection termination;
  1494.       entry for connection is made only if a valid start (SYN) was
  1495.       previously recognized */ 
  1497.    if (connection_state != PENDING)  /* saw SYN */
  1498.       {
  1499.        if (connection_state == FIN_SENT) 
  1500.            log_END("FIN");
  1501.        else
  1502.   {
  1503.            if (connection_state == RESET) 
  1504.                log_END("RST");
  1505.            else
  1506.                log_END("TRM");
  1507.   }
  1508.       }
  1509.    else
  1510.       {
  1511.        if (((have_pending_fins > 0) +
  1512.             (have_pending_rsts > 0) +
  1513.             (have_pending_othr > 0) +
  1514.             (have_pending_acks > 0)) > 1)
  1515.           pending_cmb_count++;
  1516.        else
  1517.   {
  1518.            pending_fin_count += (have_pending_fins > 0);
  1519.            pending_rst_count += (have_pending_rsts > 0);
  1520.            pending_ack_count += (have_pending_acks > 0);
  1521.            pending_oth_count += (have_pending_othr > 0);
  1522.           }
  1523.       }
  1524. }
  1527. void log_log(void)
  1528. {
  1529.  fprintf(logFP, "Input tcpdump file: %s n", input_name);
  1530.  fprintf(logFP, "Output connection file: %s n", output_name);
  1531.  fprintf(logFP, "   SYNs     %8d n", syn_count);
  1532.  fprintf(logFP, "   REQs     %8d n", req_count);
  1533.  fprintf(logFP, "   ACT-REQs %8d n", act_req_count);
  1534.  fprintf(logFP, "   RSPs     %8d n", rsp_count);
  1535.  fprintf(logFP, "   ACT-RSPs %8d n", act_rsp_count);
  1536.  fprintf(logFP, "   FINs     %8d n", fin_count);
  1537.  fprintf(logFP, "   RSTs     %8d n", rst_count);
  1538.  fprintf(logFP, "   TRMs     %8d n", trm_count);
  1539.  fprintf(logFP, "   ERRs     %8d n", err_count);
  1540.  fprintf(logFP, "Partial Connections:n");
  1541.  fprintf(logFP, " FIN only   %8d n", pending_fin_count);
  1542.  fprintf(logFP, " RST only   %8d n", pending_rst_count);
  1543.  fprintf(logFP, " ACK only   %8d n", pending_ack_count);
  1544.  fprintf(logFP, " Combos     %8d n", pending_cmb_count);
  1545.  fprintf(logFP, " Other      %8d n", pending_oth_count);
  1546. }
  1548. /* A set of event-specific data logging functions.  A critical part of
  1549.    the logging functions for Requests and Responses is to save the 
  1550.    "current" value of the sequence number (ACK or data) that marks the
  1551.    end of it as the "last" value.  This is done to tell when the 
  1552.    sequence number advances again for multiple request/response pairs
  1553.    in a connection and to allow computing its size as (current - last). */
  1555. void log_REQ(void)
  1556. {
  1557. /* parse sourse host/port */
  1558.   get_host_port(current_src, src_host, src_port);
  1560. /* parse destination host/port */
  1561.   get_host_port(current_dst, dst_host, dst_port);
  1563.   /* for requests we log the request start time  -- the tcpdump 
  1564.      timestamp on the first record associated with a request -- 
  1565.      along with the TCP connection information and the size of the 
  1566.      request data */
  1568.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: REQ %12d  %sn", 
  1569.                                     start_request_time,  
  1570.                                     dst_host, dst_port, src_host, src_port,  
  1571.                                     current_request_end - last_request_end,
  1572.                                     request_end_time);
  1573.   /* IMPORTANT */
  1574.   last_request_end = current_request_end;
  1575.   req_count++;
  1576. }
  1578. void log_RSP(void)
  1579. {
  1580. /* parse sourse host/port */
  1581.   get_host_port(current_src, src_host, src_port);
  1583. /* parse destination host/port */
  1584.   get_host_port(current_dst, dst_host, dst_port);
  1586.   /* for responses we log the response end time  -- the tcpdump 
  1587.      timestamp on the last record associated with a response -- 
  1588.      along with the TCP connection information, the size of the 
  1589.      response data, and the response start time -- the tcpdump
  1590.      timestamp on the first record associated with the response. */
  1592.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: RSP %12d  %sn", 
  1593.                                    response_end_time, 
  1594.                                    dst_host, dst_port, src_host, src_port,  
  1595.                                    current_response_end - last_response_end,
  1596.                                    start_response_time);
  1597. #ifdef FOO
  1598.   fprintf(outFP, "%s %-15s %5s > %-15s %4s RSP %d %sn", start_response_time, 
  1599.                                    src_host, src_port, dst_host, dst_port, 
  1600.                                    current_response_end - last_response_end,
  1601.                                    response_end_time);
  1602.   fprintf(outFP, "%s %s > %s RSP %dn", start_response_time, current_src, 
  1603.                                    current_dst, 
  1604.                                    current_response_end - last_response_end);
  1605. #endif
  1606.   /* IMPORTANT */
  1607.   last_response_end = current_response_end;
  1608.   rsp_count++;
  1609. }
  1611. void log_SYN(void)
  1612. {
  1613. /* parse sourse host/port */
  1614.   get_host_port(current_src, src_host, src_port);
  1616. /* parse destination host/port */
  1617.   get_host_port(current_dst, dst_host, dst_port);
  1619.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: SYNn", ts, 
  1620.                                      dst_host, dst_port, src_host, src_port);  
  1621.   syn_count++;
  1622. }
  1624. void log_END(char *how)
  1625. {
  1626.   char logical_end_time[20];
  1627.   
  1628. /* parse sourse host/port */
  1629.   get_host_port(current_src, src_host, src_port);
  1631. /* parse destination host/port */
  1632.   get_host_port(current_dst, dst_host, dst_port);
  1634.   if (strcmp(how, "FIN") == 0)
  1635.      {
  1636.       fin_count++;
  1637.       strcpy(logical_end_time, FIN_sent_time);
  1638.      }
  1639.   else
  1640.     {
  1641.      if (strcmp(how, "RST") == 0)
  1642.         {
  1643.          rst_count++;
  1644.          strcpy(logical_end_time, RST_sent_time);
  1645.         }
  1646.      else
  1647.         if (strcmp(how, "TRM") == 0)
  1648.    {
  1649.             trm_count++;
  1650.             strcpy(logical_end_time, last_connection_time);
  1651.            }
  1652.     }
  1654.   /* for termination of a connection we record the tcpdump timestamp of
  1655.      the last record of any kind associated with that conneciton along
  1656.      with the TCP connection 4-tuple and the way the connection ended
  1657.      (FIN, Reset, or just no more records in the trace). */
  1659.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: %s               %sn", 
  1660.                                     last_connection_time, 
  1661.                                     dst_host, dst_port, src_host, src_port,  
  1662.                                     how, logical_end_time);
  1663. }
  1665. void log_ACT(char *how)
  1666. {
  1667. /* parse sourse host/port */
  1668.   get_host_port(current_src, src_host, src_port);
  1670. /* parse destination host/port */
  1671.   get_host_port(current_dst, dst_host, dst_port);
  1673.   /* for activity on a SYN-less connection we record the tcpdump timestamp
  1674.      of the first record of activiy associated with that conneciton along
  1675.      with the TCP connection 4-tuple and the way the connection started
  1676.      (Request or Response). */
  1678.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: ACT-%sn", ts, 
  1679.                                     dst_host, dst_port, src_host, src_port,  
  1680.                                     how);
  1681.   if (strcmp(how, "REQ") == 0)
  1682.      act_req_count++;
  1683.   else
  1684.      if (strcmp(how, "RSP") == 0)
  1685.         act_rsp_count++;
  1686. }
  1688. void error_line(char * s)
  1689. {
  1690. /* parse sourse host/port */
  1691.   get_host_port(sh, src_host, src_port);
  1693. /* parse destination host/port */
  1694.   get_host_port(dh, dst_host, dst_port);
  1696.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: ERR: %sn", ts, 
  1697.                                    dst_host, dst_port, src_host, src_port, s);
  1698.   err_count++;
  1699. }
  1701. void error_state(char * s)
  1702. {
  1703. /* parse sourse host/port */
  1704.   get_host_port(sh, src_host, src_port);
  1706. /* parse destination host/port */
  1707.   get_host_port(dh, dst_host, dst_port);
  1709.   fprintf(outFP, "%s %-15s %5s > %-15s %4s: ERR: %sn", ts, 
  1710.                                    dst_host, dst_port, src_host, src_port, s);
  1711.   err_count++;
  1712. }
  1714. void get_host_port(char *adr, char *host, char *port)
  1715. {
  1716.  char *fp;
  1717.  char *fpx;
  1718.  char adr_field[50];
  1720.  strcpy(adr_field, adr);
  1721.  /* break string at '.' separating host and port fields (last in string) */
  1722.  fp = (char *)rindex(adr_field, '.');
  1723.  *fp = '';   /* replace '.' with string terminator */
  1724.  strcpy(host, adr_field); /* copies host name up to terminator */ 
  1726.  fp++;  /* move pointer past terminator to 1st char in port field */
  1727.  fpx = (char *)index(fp, ':');   /* see if we have the ':' after a dst port */
  1728.  if (fpx != NULL)
  1729.      *fpx = '';  /* if so, replace with string terminator */
  1730.  strcpy(port, fp); 
  1731. }
  1733. int get_sequence(char *p, unsigned long *begin, unsigned long *end,
  1734.                            unsigned long *bytes)
  1735. {
  1736.  char seq_field[50];
  1737.  char *cursor = seq_field;
  1738.  char *fp;
  1740.  strcpy (seq_field, p);
  1742.  fp = (char *)strsep(&cursor, ":" );
  1743.  if ((cursor == (char *)NULL) ||
  1744.      (fp == (char *)NULL))
  1745.     return (-1);
  1746.  else
  1747.     *begin = strtoul(fp, (char **)NULL, 10);
  1749.  fp = (char *)strsep(&cursor, "(" );
  1750.  if ((cursor == (char *)NULL) ||
  1751.      (fp == (char *)NULL))
  1752.     return (-1);
  1753.  else
  1754.     *end = strtoul(fp, (char **)NULL, 10);
  1756.  fp = (char *)strsep(&cursor, ")" );
  1757.  if ((cursor == (char *)NULL) ||
  1758.      (fp == (char *)NULL))
  1759.     return (-1);
  1760.  else
  1761.     *bytes = strtoul(fp, (char **)NULL, 10);
  1762.  return(0);
  1763. }
  1765. /*--------------------------------------------------------------*/ 
  1766. /* subtract two timevals (t1 - t0) with result in tdiff         */
  1767. /* tdiff, t1 and t0 are all pointers to struct timeval          */
  1768. /*--------------------------------------------------------------*/ 
  1769. static void
  1770. tvsub(tdiff, t1, t0)
  1771. struct timeval *tdiff, *t1, *t0;
  1772. {
  1774.         tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
  1775.         tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
  1776.         if (tdiff->tv_usec < 0)
  1777.            {
  1778.             tdiff->tv_sec--;
  1779.             tdiff->tv_usec += 1000000;
  1780.            }
  1781. }
  1783. /*--------------------------------------------------------------*/ 
  1784. /* compute the elapsed time in milliseconds to end_time         */
  1785. /* from some past time given by start_time (both formatted timevals) */
  1786. /*--------------------------------------------------------------*/ 
  1787. long elapsed_ms(char *end, char *start)
  1788. {
  1789.  struct timeval delta, end_time, start_time;
  1790.  long elapsed_time;
  1792.  char end_tmp[20];
  1793.  char start_tmp[20];
  1795.  char *cursor;
  1796.  char *cp;
  1798.  strcpy(end_tmp, end);
  1799.  cursor = end_tmp;
  1800.  cp = (char *)strsep(&cursor, "." );
  1801.  end_time.tv_sec = atoi(end_tmp);
  1802.  end_time.tv_usec = atoi(cursor);
  1804.  strcpy(start_tmp, start);
  1805.  cursor = start_tmp;
  1806.  cp = (char *)strsep(&cursor, "." );
  1807.  start_time.tv_sec = atoi(start_tmp);
  1808.  start_time.tv_usec = atoi(cursor);
  1810.  tvsub(&delta, &end_time, &start_time);
  1811.  /* express as milliseconds */
  1812.  elapsed_time = (delta.tv_sec * 1000) + (delta.tv_usec/1000);
  1813.  return (elapsed_time);
  1814. }