Changeset 9636216

Timestamp:

02/23/16 16:03:14 (5 years ago)

Author:

Perry Lorier <git@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, master, ndag_format, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

7d1ada1

Parents:

3fe009c

Message:

Trivial whitespace fixes.

File:

• lib/trace.c (modified) (81 diffs)

lib/trace.c

@@ -2 +2 @@
  * This file is part of libtrace
  *
- * Copyright (c) 2007,2008,2009,2010 The University of Waikato, Hamilton, 
+ * Copyright (c) 2007,2008,2009,2010 The University of Waikato, Hamilton,
  * New Zealand.
  *
- * Authors: Daniel Lawson 
+ * Authors: Daniel Lawson
  *          Perry Lorier
- *          Shane Alcock 
- *          
+ *          Shane Alcock
+ *
  * All rights reserved.
  *
- * This code has been developed by the University of Waikato WAND 
+ * This code has been developed by the University of Waikato WAND
  * research group. For further information please see http://www.wand.net.nz/
  *
@@ -115 +115 @@
         dest[n]='\0';
 }
- 
+
 static char *xstrndup(const char *src,size_t n)
-{       
+{
         char *ret=(char*)malloc(n+1);
         if (ret==NULL) {
@@ -153 +153 @@
 }
 
-/* Prints help information for libtrace 
+/* Prints help information for libtrace
  *
  * Function prints out some basic help information regarding libtrace,
@@ -176 +176 @@
 {
         struct libtrace_format_t *tmp;
-        
+
         /* Try and guess based on filename */
         for(tmp = formats_list; tmp; tmp=tmp->next) {
@@ -198 +198 @@
                 }
         }
-        
+
         /* Oh well */
         return;
@@ -211 +211 @@
  *  erf:/path/to/erf/file
  *  erf:/path/to/erf/file.gz
- *  erf:-                       (stdin)
+ *  erf:-                       (stdin)
  *  dag:/dev/dagcard
- *  pcapint:pcapinterface               (eg: pcapint:eth0)
+ *  pcapint:pcapinterface               (eg: pcapint:eth0)
  *  pcapfile:/path/to/pcap/file
  *  pcapfile:-
@@ -224 +224 @@
  */
 DLLEXPORT libtrace_t *trace_create(const char *uri) {
-        libtrace_t *libtrace = 
+        libtrace_t *libtrace =
                         (libtrace_t *)malloc(sizeof(libtrace_t));
         char *scan = 0;
-        const char *uridata = 0;                  
+        const char *uridata = 0;
 
         trace_init();
@@ -237 +237 @@
                 return NULL;
         }
-        
+
         libtrace->err.err_num = TRACE_ERR_NOERROR;
         libtrace->format=NULL;
-        
+
         libtrace->event.tdelta = 0.0;
         libtrace->event.packet = NULL;
@@ -287 +287 @@
          * libtrace->uridata contains the appropriate data for this
          */
-       
-        /* Call the init_input function for the matching capture format */ 
+
+        /* Call the init_input function for the matching capture format */
         if (libtrace->format->init_input) {
                 int err=libtrace->format->init_input(libtrace);
                 assert (err==-1 || err==0);
                 if (err==-1) {
-                        /* init_input should call trace_set_err to set 
-                         * the error message
+                        /* init_input should call trace_set_err to set the
+                         * error message
                          */
                         return libtrace;
@@ -303 +303 @@
                 return libtrace;
         }
-        
+
         if (scan)
                 free(scan);
@@ -326 +326 @@
 
         trace_init();
-        
+
         libtrace->err.err_num = TRACE_ERR_NOERROR;
 
@@ -334 +334 @@
                 xstrncpy(scan,uri, (size_t)(uridata - uri));
         }
-        
+
         libtrace->err.err_num = TRACE_ERR_NOERROR;
         libtrace->format=NULL;
-        
+
         libtrace->event.tdelta = 0.0;
         libtrace->event.packet = NULL;
@@ -348 +348 @@
         libtrace->io = NULL;
         libtrace->filtered_packets = 0;
-        
+
         for(tmp=formats_list;tmp;tmp=tmp->next) {
                 if (strlen(scan) == strlen(tmp->name) &&
@@ -369 +369 @@
 }
 
-/* Creates an output trace from a URI. 
+/* Creates an output trace from a URI.
  *
  * @param uri   the uri string describing the output format and destination
- * @returns opaque pointer to a libtrace_output_t 
+ * @returns opaque pointer to a libtrace_output_t
  *
  *  If an error occured when attempting to open the output trace, NULL is
- *  returned and trace_errno is set. 
- */
-        
+ *  returned and trace_errno is set.
+ */
+
 DLLEXPORT libtrace_out_t *trace_create_output(const char *uri) {
-        libtrace_out_t *libtrace = 
+        libtrace_out_t *libtrace =
                         (libtrace_out_t*)malloc(sizeof(libtrace_out_t));
-        
+
         char *scan = 0;
         const char *uridata = 0;
@@ -392 +392 @@
         libtrace->format = NULL;
         libtrace->uridata = NULL;
-        
+
         /* Parse the URI to determine what capture format we want to write */
 
@@ -400 +400 @@
                 return libtrace;
         }
-        
+
         /* Attempt to find the format in the list of supported formats */
         for(tmp=formats_list;tmp;tmp=tmp->next) {
@@ -469 +469 @@
 
 /* Start an output trace */
-DLLEXPORT int trace_start_output(libtrace_out_t *libtrace) 
+DLLEXPORT int trace_start_output(libtrace_out_t *libtrace)
 {
         assert(libtrace);
@@ -505 +505 @@
                 return -1;
         }
-        
+
         /* If the capture format supports configuration, try using their
          * native configuration first */
@@ -515 +515 @@
 
         /* If we get here, either the native configuration failed or the
-         * format did not support configuration. However, libtrace can 
+         * format did not support configuration. However, libtrace can
          * deal with some options itself, so give that a go */
         switch(option) {
@@ -523 +523 @@
                                 trace_get_err(libtrace);
                         }
-                        if (*(int*)value<0 
+                        if (*(int*)value<0
                                 || *(int*)value>LIBTRACE_PACKET_BUFSIZE) {
                                 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,
@@ -545 +545 @@
                 case TRACE_OPTION_META_FREQ:
                         if (!trace_is_err(libtrace)) {
-                                trace_set_err(libtrace, 
+                                trace_set_err(libtrace,
                                                 TRACE_ERR_OPTION_UNAVAIL,
                                                 "This format does not support meta-data gathering");
@@ -552 +552 @@
                 case TRACE_OPTION_EVENT_REALTIME:
                         if (!trace_is_err(libtrace)) {
-                                trace_set_err(libtrace, 
+                                trace_set_err(libtrace,
                                                 TRACE_ERR_OPTION_UNAVAIL,
                                                 "This format does not support realtime events");
                         }
                         return -1;
-                        
+
         }
         if (!trace_is_err(libtrace)) {
@@ -566 +566 @@
 }
 
-DLLEXPORT int trace_config_output(libtrace_out_t *libtrace, 
+DLLEXPORT int trace_config_output(libtrace_out_t *libtrace,
                 trace_option_output_t option,
                 void *value) {
-        
+
         /* Unlike the input options, libtrace does not natively support any of
          * the output options - the format module must be able to deal with
@@ -623 +623 @@
  * @param libtrace      the output trace file to be destroyed
  */
-DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) 
+DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace)
 {
         assert(libtrace);
@@ -633 +633 @@
 }
 
-DLLEXPORT libtrace_packet_t *trace_create_packet(void) 
-{
-        libtrace_packet_t *packet = 
+DLLEXPORT libtrace_packet_t *trace_create_packet(void)
+{
+        libtrace_packet_t *packet =
                 (libtrace_packet_t*)calloc((size_t)1,sizeof(libtrace_packet_t));
 
@@ -644 +644 @@
 
 DLLEXPORT libtrace_packet_t *trace_copy_packet(const libtrace_packet_t *packet) {
-        libtrace_packet_t *dest = 
+        libtrace_packet_t *dest =
                 (libtrace_packet_t *)malloc(sizeof(libtrace_packet_t));
         if (!dest) {
@@ -663 +663 @@
         /* Reset the cache - better to recalculate than try to convert
          * the values over to the new packet */
-        trace_clear_cache(dest);        
+        trace_clear_cache(dest);
         /* Ooooh nasty memcpys! This is why we want to avoid copying packets
          * as much as possible */
@@ -678 +678 @@
                 free(packet->buffer);
         }
-        packet->buf_control=(buf_control_t)'\0'; 
+        packet->buf_control=(buf_control_t)'\0';
                                 /* A "bad" value to force an assert
                                  * if this packet is ever reused
                                  */
         free(packet);
-}       
+}
 
 /* Read one packet from the trace into buffer. Note that this function will
  * block until a packet is read (or EOF is reached).
  *
- * @param libtrace      the libtrace opaque pointer
- * @param packet        the packet opaque pointer
+ * @param libtrace      the libtrace opaque pointer
+ * @param packet        the packet opaque pointer
  * @returns 0 on EOF, negative value on error
  *
@@ -702 +702 @@
                 return -1;
         }
-        if (!(packet->buf_control==TRACE_CTRL_PACKET || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
+        if (!(packet->buf_control==TRACE_CTRL_PACKET
+                    || packet->buf_control==TRACE_CTRL_EXTERNAL)) {
                 trace_set_err(libtrace,TRACE_ERR_BAD_STATE,"Packet passed to trace_read_packet() is invalid\n");
                 return -1;
         }
         assert(packet);
-      
-        /* Store the trace we are reading from into the packet opaque 
+
+        /* Store the trace we are reading from into the packet opaque
          * structure */
         packet->trace = libtrace;
@@ -739 +740 @@
                                         return ~0U;
                                 }
-                                
+
                                 if (filtret == 0) {
                                         ++libtrace->filtered_packets;
@@ -763 +764 @@
  * appropriate capture format header for the format type that the packet is
  * being converted to. This also allows for a packet to be converted into
- * just about capture format that is supported by libtrace, provided the 
+ * just about capture format that is supported by libtrace, provided the
  * format header is present in the buffer.
  *
  * This function is primarily used to convert packets received via the RT
  * protocol back into their original capture format. The RT header encapsulates
- * the original capture format header, so after removing it the packet must 
+ * the original capture format header, so after removing it the packet must
  * have it's header and payload pointers updated and the packet format and type
  * changed, amongst other things.
  *
- * Intended only for internal use at this point - this function is not 
+ * Intended only for internal use at this point - this function is not
  * available through the external libtrace API.
  */
@@ -780 +781 @@
         assert(packet);
         assert(trace);
-        
+
         /* XXX Proper error handling?? */
         if (buffer == NULL)
@@ -789 +790 @@
                 return -1;
         }
-        
+
         packet->trace = trace;
-        
+
         /* Clear packet cache */
         trace_clear_cache(packet);
@@ -799 +800 @@
                                 buffer, rt_type, flags);
         }
-        trace_set_err(trace, TRACE_ERR_UNSUPPORTED, 
+        trace_set_err(trace, TRACE_ERR_UNSUPPORTED,
                         "This format does not support preparing packets\n");
         return -1;
@@ -813 +814 @@
 DLLEXPORT int trace_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
         assert(libtrace);
-        assert(packet); 
+        assert(packet);
         /* Verify the packet is valid */
         if (!libtrace->started) {
@@ -841 +842 @@
                  * wire lengths to be the "remaining" value. If the packet has
                  * been padded to increase the capture length, we don't want
-                 * to allow subsequent protocol decoders to consider the 
+                 * to allow subsequent protocol decoders to consider the
                  * padding as part of the packet.
                  *
@@ -851 +852 @@
                  * better off returning an incomplete TCP header in that case.
                  */
-                
+
                 cap_len = trace_get_capture_length(packet);
                 wire_len = trace_get_wire_length(packet);
@@ -860 +861 @@
                  * massively negative wire lens. We could assert fail here on
                  * them, but we could at least try the capture length instead.
-                 * 
+                 *
                  * You may still run into problems if you try to write that
                  * packet, but at least reading should work OK.
@@ -876 +877 @@
 
 
-/* Get a pointer to the first byte of the packet payload 
+/* Get a pointer to the first byte of the packet payload
  *
  * DEPRECATED - use trace_get_packet_buffer() instead */
@@ -883 +884 @@
 }
 
-/* Get the current time in DAG time format 
- * @param packet        a pointer to a libtrace_packet structure
+/* Get the current time in DAG time format
+ * @param packet        a pointer to a libtrace_packet structure
  * @returns a 64 bit timestamp in DAG ERF format (upper 32 bits are the seconds
  * past 1970-01-01, the lower 32bits are partial seconds)
- */ 
+ */
 DLLEXPORT uint64_t trace_get_erf_timestamp(const libtrace_packet_t *packet) {
         if (packet->trace->format->get_erf_timestamp) {
@@ -913 +914 @@
                 return (uint64_t)0;
         }
-                      
 }
 
@@ -922 +922 @@
  * @author Daniel Lawson
  * @author Perry Lorier
- */ 
+ */
 DLLEXPORT struct timeval trace_get_timeval(const libtrace_packet_t *packet) {
         struct timeval tv;
@@ -934 +934 @@
                 tv.tv_sec = ts >> 32;
                 tv.tv_usec = ((ts&0xFFFFFFFF)*1000000)>>32;
-                if (tv.tv_usec >= 1000000) {
-                        tv.tv_usec -= 1000000;
-                        tv.tv_sec += 1;
-                }
+                if (tv.tv_usec >= 1000000) {
+                        tv.tv_usec -= 1000000;
+                        tv.tv_sec += 1;
+                }
         } else if (packet->trace->format->get_timespec) {
                 struct timespec ts = packet->trace->format->get_timespec(packet);
@@ -966 +966 @@
                 ts.tv_sec = erfts >> 32;
                 ts.tv_nsec = ((erfts&0xFFFFFFFF)*1000000000)>>32;
-                if (ts.tv_nsec >= 1000000000) {
-                        ts.tv_nsec -= 1000000000;
-                        ts.tv_sec += 1;
-                }
+                if (ts.tv_nsec >= 1000000000) {
+                        ts.tv_nsec -= 1000000000;
+                        ts.tv_sec += 1;
+                }
                 return ts;
         } else if (packet->trace->format->get_timeval) {
@@ -993 +993 @@
 
 /* Get the current time in floating point seconds
- * @param packet        a pointer to a libtrace_packet structure
+ * @param packet        a pointer to a libtrace_packet structure
  * @returns time that this packet was seen in 64bit floating point seconds
- */ 
+ */
 DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) {
         double seconds = 0.0;
@@ -1022 +1022 @@
 }
 
-DLLEXPORT size_t trace_get_capture_length(const libtrace_packet_t *packet) 
+DLLEXPORT size_t trace_get_capture_length(const libtrace_packet_t *packet)
 {
         /* Cache the capture length */
@@ -1029 +1029 @@
                         return ~0U;
                 /* Cast away constness because this is "just" a cache */
-                ((libtrace_packet_t*)packet)->capture_length = 
+                ((libtrace_packet_t*)packet)->capture_length =
                         packet->trace->format->get_capture_length(packet);
         }
@@ -1037 +1037 @@
         return packet->capture_length;
 }
-        
+
 /* Get the size of the packet as it was seen on the wire.
  * @param packet        a pointer to a libtrace_packet structure
@@ -1044 +1044 @@
  * @note Due to the trace being a header capture, or anonymisation this may
  * not be the same as the Capture Len.
- */ 
+ */
 DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){
-        
+
         if (packet->wire_length == -1) {
-                if (!packet->trace->format->get_wire_length) 
+                if (!packet->trace->format->get_wire_length)
                         return ~0U;
-                ((libtrace_packet_t *)packet)->wire_length = 
+                ((libtrace_packet_t *)packet)->wire_length =
                         packet->trace->format->get_wire_length(packet);
         }
@@ -1060 +1060 @@
 
 /* Get the length of the capture framing headers.
- * @param packet        the packet opaque pointer
+ * @param packet        the packet opaque pointer
  * @returns the size of the packet as it was on the wire.
- * @note this length corresponds to the difference between the size of a 
+ * @note this length corresponds to the difference between the size of a
  * captured packet in memory, and the captured length of the packet
- */ 
+ */
 DLLEXPORT SIMPLE_FUNCTION
 size_t trace_get_framing_length(const libtrace_packet_t *packet) {
@@ -1075 +1075 @@
 
 /* Get the type of the link layer
- * @param packet        a pointer to a libtrace_packet structure
+ * @param packet        a pointer to a libtrace_packet structure
  * @returns libtrace_linktype_t
  */
@@ -1101 +1101 @@
  * which in turn is stored inside the new packet object...
  */
-DLLEXPORT libtrace_eventobj_t trace_event(libtrace_t *trace, 
+DLLEXPORT libtrace_eventobj_t trace_event(libtrace_t *trace,
                 libtrace_packet_t *packet) {
         libtrace_eventobj_t event = {TRACE_EVENT_IOWAIT,0,0.0,0};
@@ -1113 +1113 @@
         /* Clear the packet cache */
         trace_clear_cache(packet);
-        
+
         /* Store the trace we are reading from into the packet opaque
          * structure */
@@ -1120 +1120 @@
         if (packet->trace->format->trace_event) {
                 /* Note: incrementing accepted, filtered etc. packet
-                 * counters is handled by the format-specific 
+                 * counters is handled by the format-specific
                  * function so don't increment them here.
                  */
@@ -1147 +1147 @@
         filter->filter.bf_insns = (struct bpf_insn *)
                 malloc(sizeof(struct bpf_insn) * bf_len);
-        
+
         memcpy(filter->filter.bf_insns, bf_insns,
                         bf_len * sizeof(struct bpf_insn));
-        
+
         filter->filter.bf_len = bf_len;
         filter->filterstring = NULL;
         filter->jitfilter = NULL;
         /* "flag" indicates that the filter member is valid */
-        filter->flag = 1; 
-        
+        filter->flag = 1;
+
         return filter;
 #endif
@@ -1186 +1186 @@
                 pcap_freecode(&filter->filter);
 #ifdef HAVE_LLVM
-        if (filter->jitfilter) 
+        if (filter->jitfilter)
                 destroy_program(filter->jitfilter);
 #endif
@@ -1204 +1204 @@
 static int trace_bpf_compile(libtrace_filter_t *filter,
                 const libtrace_packet_t *packet,
-                void *linkptr, 
+                void *linkptr,
                 libtrace_linktype_t linktype    ) {
 #ifdef HAVE_BPF_FILTER
@@ -1215 +1215 @@
                 return -1;
         }
-        
+
         if (filter->filterstring && ! filter->flag) {
                 pcap_t *pcap = NULL;
@@ -1234 +1234 @@
                 /* build filter */
                 assert(pcap);
-                if (pcap_compile( pcap, &filter->filter, filter->filterstring, 
+                if (pcap_compile( pcap, &filter->filter, filter->filterstring,
                                         1, 0)) {
                         trace_set_err(packet->trace,TRACE_ERR_BAD_FILTER,
-                                        "Unable to compile the filter \"%s\": %s", 
+                                        "Unable to compile the filter \"%s\": %s",
                                         filter->filterstring,
                                         pcap_geterr(pcap));
@@ -1273 +1273 @@
 
         if (linktype == TRACE_TYPE_NONDATA)
-                return 1;       
+                return 1;
 
         if (libtrace_to_pcap_dlt(linktype)==TRACE_DLT_ERROR) {
-                
+
                 /* If we cannot get a suitable DLT for the packet, it may
                  * be because the packet is encapsulated in a link type that
@@ -1282 +1282 @@
                  * popping off headers until we either can find a suitable
                  * link type or we can't do any more sensible decapsulation. */
-                
+
                 /* Copy the packet, as we don't want to trash the one we
                  * were passed in */
@@ -1290 +1290 @@
                 while (libtrace_to_pcap_dlt(linktype) == TRACE_DLT_ERROR) {
                         if (!demote_packet(packet_copy)) {
-                                trace_set_err(packet->trace, 
+                                trace_set_err(packet->trace,
                                                 TRACE_ERR_NO_CONVERSION,
                                                 "pcap does not support this format");
@@ -1302 +1302 @@
 
         }
-        
+
         linkptr = trace_get_packet_buffer(packet_copy,NULL,&clen);
         if (!linkptr) {
@@ -1311 +1311 @@
         }
 
-        /* We need to compile the filter now, because before we didn't know 
+        /* We need to compile the filter now, because before we didn't know
          * what the link type was
          */
@@ -1352 +1352 @@
  * @returns a signed value containing the direction flag, or -1 if this is not supported
  */
-DLLEXPORT libtrace_direction_t trace_set_direction(libtrace_packet_t *packet, 
-                libtrace_direction_t direction) 
+DLLEXPORT libtrace_direction_t trace_set_direction(libtrace_packet_t *packet,
+                libtrace_direction_t direction)
 {
         assert(packet);
@@ -1370 +1370 @@
  * for a special trace.
  */
-DLLEXPORT libtrace_direction_t trace_get_direction(const libtrace_packet_t *packet) 
+DLLEXPORT libtrace_direction_t trace_get_direction(const libtrace_packet_t *packet)
 {
         assert(packet);
@@ -1385 +1385 @@
 #define DYNAMIC(x) ((49152 < (x)) && ((x) < 65535))
 #define SERVER(x) ROOT_SERVER(x) || NONROOT_SERVER(x)
-#define CLIENT(x) ROOT_CLIENT(x) || NONROOT_CLIENT(x) 
+#define CLIENT(x) ROOT_CLIENT(x) || NONROOT_CLIENT(x)
 
 /* Attempt to deduce the 'server' port
@@ -1393 +1393 @@
  * @returns a hint as to which port is the server port
  */
-DLLEXPORT int8_t trace_get_server_port(UNUSED uint8_t protocol, 
-                uint16_t source, uint16_t dest) 
+DLLEXPORT int8_t trace_get_server_port(UNUSED uint8_t protocol,
+                uint16_t source, uint16_t dest)
 {
         /*
@@ -1407 +1407 @@
          * * flip a coin.
          */
-        
+
         /* equal */
         if (source == dest)
@@ -1453 +1453 @@
                 return USE_SOURCE;
         }
-        
+
         /* nonroot client */
         if (NONROOT_CLIENT(source) && NONROOT_CLIENT(dest)) {
-                if (source < dest) 
+                if (source < dest)
                         return USE_SOURCE;
                 return USE_DEST;
@@ -1476 +1476 @@
                 return USE_SOURCE;
         /*
-        if (SERVER(source) && CLIENT(dest)) 
+        if (SERVER(source) && CLIENT(dest))
                 return USE_SOURCE;
-        
-        if (SERVER(dest) && CLIENT(source)) 
+
+        if (SERVER(dest) && CLIENT(source))
                 return USE_DEST;
-        if (ROOT_SERVER(source) && !ROOT_SERVER(dest)) 
+        if (ROOT_SERVER(source) && !ROOT_SERVER(dest))
                 return USE_SOURCE;
-        if (ROOT_SERVER(dest) && !ROOT_SERVER(source)) 
+        if (ROOT_SERVER(dest) && !ROOT_SERVER(source))
                 return USE_DEST;
         */
@@ -1489 +1489 @@
         if (source < dest) {
                 return USE_SOURCE;
-        } 
+        }
         return USE_DEST;
-        
+
 }
 
@@ -1520 +1520 @@
  *
  * Returns a pointer to the URI data, but updates the format parameter to
- * point to a copy of the format component. 
+ * point to a copy of the format component.
  */
 
 DLLEXPORT const char * trace_parse_uri(const char *uri, char **format) {
         const char *uridata = 0;
-        
+
         if((uridata = strchr(uri,':')) == NULL) {
                 /* Badly formed URI - needs a : */
@@ -1542 +1542 @@
         /* Push uridata past the delimiter */
         uridata++;
-        
+
         return uridata;
 }
 
-enum base_format_t trace_get_format(libtrace_packet_t *packet) 
+enum base_format_t trace_get_format(libtrace_packet_t *packet)
 {
         assert(packet);
@@ -1552 +1552 @@
         return packet->trace->format->type;
 }
-        
+
 DLLEXPORT libtrace_err_t trace_get_err(libtrace_t *trace)
 {
@@ -1650 +1650 @@
                 }
                 if (trace->format->seek_seconds) {
-                        double seconds =  
+                        double seconds =
                                 (ts>>32) + ((ts & UINT_MAX)*1.0 / UINT_MAX);
                         return trace->format->seek_seconds(trace,seconds);
@@ -1674 +1674 @@
                 }
                 if (trace->format->seek_erf) {
-                        uint64_t timestamp = 
+                        uint64_t timestamp =
                                 ((uint64_t)((uint32_t)seconds) << 32) + \
                             (uint64_t)(( seconds - (uint32_t)seconds   ) * UINT_MAX);
@@ -1737 +1737 @@
 
 
-/* Creates a libtrace packet from scratch using the contents of the provided 
+/* Creates a libtrace packet from scratch using the contents of the provided
  * buffer as the packet payload.
  *
  * Unlike trace_prepare_packet(), the buffer should not contain any capture
- * format headers; instead this function will add the PCAP header to the 
+ * format headers; instead this function will add the PCAP header to the
  * packet record. This also means only PCAP packets can be constructed using
  * this function.
@@ -1763 +1763 @@
         /* We need a trace to attach the constructed packet to (and it needs
          * to be PCAP) */
-        if (NULL == deadtrace) 
+        if (NULL == deadtrace)
                 deadtrace=trace_create_dead("pcapfile");
 
@@ -1863 +1863 @@
 
         /* Now, verify that the format has at least the minimum functionality.
-         * 
+         *
          * This #if can be changed to a 1 to output warnings about inconsistent
          * functions being provided by format modules.  This generally is very
          * noisy, as almost all modules don't implement one or more functions
-         * for various reasons.  This is very useful when checking a new 
+         * for various reasons.  This is very useful when checking a new
          * format module is sane.
-         */ 
+         */
 #if 0
         if (f->init_input) {
@@ -1883 +1883 @@
                 REQUIRE(get_framing_length);
                 REQUIRE(trace_event);
-                if (!f->get_erf_timestamp 
+                if (!f->get_erf_timestamp
                         && !f->get_seconds
                         && !f->get_timeval) {