Changeset 4bd8a5b


Ignore:
Timestamp:
12/24/06 17:05:29 (15 years ago)
Author:
Perry Lorier <perry@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
870e501
Parents:
778d459
Message:

Cleanup a gazillion warnings

Location:
lib
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • lib/dagformat.h

    re2aebe7 r4bd8a5b  
    101101
    102102/** sizeof(dag_record_t) without the payload helpers */
    103 #define dag_record_size         16
     103#define dag_record_size         16U
    104104
    105105#endif /* _DAGFORMAT_H_ */
  • lib/format_duck.c

    rac0fdbf r4bd8a5b  
    140140       
    141141        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    142                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     142                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    143143                packet->buf_control = TRACE_CTRL_PACKET;
    144144                if (!packet->buffer) {
     
    181181
    182182        if ((numbytes = libtrace_io_read(INPUT->file, packet->payload,
    183                                         duck_size)) != (int)duck_size) {
     183                                        (size_t)duck_size)) != (int)duck_size) {
    184184                if (numbytes == -1) {
    185185                        trace_set_err(libtrace, errno, "Reading DUCK failed");
  • lib/format_erf.c

    r5e85c23 r4bd8a5b  
    6060#define COLLECTOR_PORT 3435
    6161
    62 static struct libtrace_format_t erf;
     62static struct libtrace_format_t erfformat;
    6363
    6464#define DATA(x) ((struct erf_format_data_t *)x->format_data)
     
    173173
    174174                libtrace_io_seek(DATA(libtrace)->seek.index,
    175                                 current*sizeof(record),
     175                                (int64_t)(current*sizeof(record)),
    176176                                SEEK_SET);
    177177                libtrace_io_read(DATA(libtrace)->seek.index,
     
    192192        do {
    193193                libtrace_io_seek(DATA(libtrace)->seek.index,
    194                                 current*sizeof(record),SEEK_SET);
     194                                (int64_t)(current*sizeof(record)),SEEK_SET);
    195195                libtrace_io_read(DATA(libtrace)->seek.index,
    196196                                &record,sizeof(record));
     
    199199
    200200        /* We've found our location in the trace, now use it. */
    201         libtrace_io_seek(INPUT.file,record.offset,SEEK_SET);
     201        libtrace_io_seek(INPUT.file,(int64_t) record.offset,SEEK_SET);
    202202
    203203        return 0; /* success */
     
    316316
    317317        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    318                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     318                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    319319                packet->buf_control = TRACE_CTRL_PACKET;
    320320                if (!packet->buffer) {
     
    332332        if ((numbytes=libtrace_io_read(INPUT.file,
    333333                                        packet->buffer,
    334                                         dag_record_size)) == -1) {
     334                                        (size_t)dag_record_size)) == -1) {
    335335                trace_set_err(libtrace,errno,"read(%s)",
    336336                                libtrace->uridata);
     
    354354        if ((numbytes=libtrace_io_read(INPUT.file,
    355355                                        buffer2,
    356                                         size)) != (int)size) {
     356                                        (size_t)size)) != (int)size) {
    357357                if (numbytes==-1) {
    358358                        trace_set_err(libtrace,errno, "read(%s)", libtrace->uridata);
     
    377377
    378378        if ((numbytes =
    379                 libtrace_io_write(OUTPUT.file, erfptr, dag_record_size + pad))
    380                         != (int)dag_record_size+pad) {
     379                libtrace_io_write(OUTPUT.file,
     380                                erfptr,
     381                                (size_t)(dag_record_size + pad)))
     382                        != (int)(dag_record_size+pad)) {
    381383                trace_set_err_out(libtrace,errno,
    382384                                "write(%s)",libtrace->uridata);
     
    385387
    386388        size=ntohs(erfptr->rlen)-(dag_record_size+pad);
    387         numbytes=libtrace_io_write(OUTPUT.file, buffer, size);
     389        numbytes=libtrace_io_write(OUTPUT.file, buffer, (size_t)size);
    388390        if (numbytes != size) {
    389391                trace_set_err_out(libtrace,errno,
     
    434436{
    435437        int numbytes = 0;
    436         int pad = 0;
     438        unsigned int pad = 0;
    437439        dag_record_t *dag_hdr = (dag_record_t *)packet->header;
    438440        void *payload = packet->payload;
     
    589591}
    590592
    591 static struct libtrace_format_t erf = {
     593static struct libtrace_format_t erfformat = {
    592594        "erf",
    593595        "$Id$",
     
    626628
    627629void erf_constructor(void) {
    628         register_format(&erf);
    629 }
     630        register_format(&erfformat);
     631}
  • lib/format_helper.c

    r2a1a502 r4bd8a5b  
    3232#include <sys/types.h>
    3333#include <fcntl.h> /* for O_LARGEFILE */
     34#include <math.h>
    3435#include "libtrace.h"
    3536#include "libtrace_int.h"
     
    112113
    113114        ts=trace_get_seconds(trace->event.packet);
    114         if (trace->event.tdelta!=0.0) {
     115        if (fabs(trace->event.tdelta)<1e-9) {
    115116                /* Get the adjusted current time */
    116117                gettimeofday(&stv, NULL);
  • lib/format_legacy.c

    rcab58c5 r4bd8a5b  
    116116        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    117117                packet->buf_control = TRACE_CTRL_PACKET;
    118                 packet->buffer=malloc(LIBTRACE_PACKET_BUFSIZE);
     118                packet->buffer=malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    119119        }
    120120        buffer = packet->buffer;
     
    136136        if ((numbytes=libtrace_io_read(INPUT.file,
    137137                                        buffer,
    138                                         64)) != 64) {
     138                                        (size_t)64)) != 64) {
    139139                if (numbytes!=0) {
    140140                        trace_set_err(libtrace,errno,"read(%s)",libtrace->uridata);
  • lib/format_linux.c

    r496b8e5 r4bd8a5b  
    118118        if (bind(FORMAT(libtrace->format_data)->fd,
    119119                                (struct sockaddr*)&addr,
    120                                 sizeof(addr))==-1) {
     120                                (socklen_t)sizeof(addr))==-1) {
    121121                free(libtrace->format_data);
    122122                return -1;
     
    151151                        SO_TIMESTAMP,
    152152                        &one,
    153                         sizeof(one))==-1) {
     153                        (socklen_t)sizeof(one))==-1) {
    154154                perror("setsockopt(SO_TIMESTAMP)");
    155155        }
     
    237237
    238238        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    239                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     239                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    240240                packet->buf_control = TRACE_CTRL_PACKET;
    241241        }
     
    303303        hdr.sll_pkttype = 0;
    304304        hdr.sll_halen = htons(6); /* FIXME */
    305         memcpy(hdr.sll_addr,packet->payload,hdr.sll_halen);
     305        memcpy(hdr.sll_addr,packet->payload,(size_t)hdr.sll_halen);
    306306
    307307        return sendto(DATAOUT(trace)->fd,
     
    309309                        trace_get_capture_length(packet),
    310310                        0,
    311                         (struct sockaddr*)&hdr, sizeof(hdr));
     311                        (struct sockaddr*)&hdr, (socklen_t)sizeof(hdr));
    312312
    313313}
  • lib/format_pcapfile.c

    r6ef54f6 r4bd8a5b  
    215215
    216216        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    217                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     217                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    218218                packet->buf_control = TRACE_CTRL_PACKET;
    219219        }
     
    237237        err=libtrace_io_read(DATA(libtrace)->file,
    238238                        (char*)packet->buffer+sizeof(libtrace_pcapfile_pkt_hdr_t),
    239                         swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen)
     239                        (size_t)swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen)
    240240                        );
    241241
     
    447447        }
    448448        pcapptr = (libtrace_pcapfile_pkt_hdr_t *)packet->header;
    449         pcapptr->caplen = swapl(packet->trace,size);
     449        pcapptr->caplen = swapl(packet->trace,(uint32_t)size);
    450450        return trace_get_capture_length(packet);
    451451}
  • lib/format_rt.c

    reb1aab2 r4bd8a5b  
    5353#define RT_INFO ((struct rt_format_data_t*)libtrace->format_data)
    5454
    55 static char *rt_deny_reason(uint8_t reason) {
     55static char *rt_deny_reason(enum rt_conn_denied_t reason)
     56{
    5657        char *string = 0;
    5758
     
    111112        }
    112113
     114        memset(&remote,0, sizeof(remote));
    113115        remote.sin_family = AF_INET;
    114116        remote.sin_port = htons(RT_INFO->port);
    115117        remote.sin_addr = *((struct in_addr *)he->h_addr);
    116         memset(&(remote.sin_zero), 0, 8);
    117118
    118119        if (connect(RT_INFO->input_fd, (struct sockaddr *)&remote,
    119                                 sizeof(struct sockaddr)) == -1) {
     120                                (socklen_t)sizeof(struct sockaddr)) == -1) {
    120121                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
    121122                                "Could not connect to host %s on port %d",
     
    217218                        RT_INFO->hostname =
    218219                                (char *)strndup(uridata,
    219                                                 (scan - uridata));
     220                                                (size_t)(scan - uridata));
    220221                        RT_INFO->port =
    221222                                atoi(++scan);
     
    284285}
    285286
    286 #define RT_BUF_SIZE 4000
    287 
    288 static int rt_read(libtrace_t *libtrace, void **buffer, size_t len, int block) {
     287#define RT_BUF_SIZE 4000U
     288
     289static int rt_read(libtrace_t *libtrace, void **buffer, size_t len, int block)
     290{
    289291        int numbytes;
    290292       
     
    292294       
    293295        if (!RT_INFO->pkt_buffer) {
    294                 RT_INFO->pkt_buffer = malloc(RT_BUF_SIZE);
     296                RT_INFO->pkt_buffer = malloc((size_t)RT_BUF_SIZE);
    295297                RT_INFO->buf_current = RT_INFO->pkt_buffer;
    296298                RT_INFO->buf_filled = 0;
     
    441443        char *buf_ptr;
    442444        int numbytes = 0;
    443         unsigned int to_write = 0;
     445        size_t to_write = 0;
    444446        rt_header_t *hdr;
    445447        rt_ack_t *ack_hdr;
     
    516518
    517519        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
    518                 if (rt_read(libtrace, &packet->buffer, RT_INFO->rt_hdr.length,blocking) != RT_INFO->rt_hdr.length) {
     520                if (rt_read(libtrace,
     521                                        &packet->buffer,
     522                                        (size_t)RT_INFO->rt_hdr.length,
     523                                        blocking) != RT_INFO->rt_hdr.length) {
    519524                        return -1;
    520525                }
     
    538543                        case TRACE_RT_STATUS:
    539544                                if (rt_read(libtrace, &packet->buffer,
    540                                         RT_INFO->rt_hdr.length, blocking) !=
     545                                        (size_t)RT_INFO->rt_hdr.length,
     546                                        blocking) !=
    541547                                                RT_INFO->rt_hdr.length) {
    542548                                        return -1;
     
    548554                        case TRACE_RT_DUCK_2_5:
    549555                                if (rt_read(libtrace, &packet->buffer,
    550                                         RT_INFO->rt_hdr.length, blocking) !=
     556                                        (size_t)RT_INFO->rt_hdr.length,
     557                                        blocking) !=
    551558                                                RT_INFO->rt_hdr.length) {
    552559                                        return -1;
  • lib/format_wag.c

    rcab58c5 r4bd8a5b  
    9292
    9393static int wag_init_input(libtrace_t *libtrace) {
    94         libtrace->format_data = calloc(1, sizeof(struct wag_format_data_t));
    95 
     94        libtrace->format_data = calloc((size_t)1,
     95                                        sizeof(struct wag_format_data_t));
    9696        return 0;
    9797}
     
    123123static int wtf_init_input(libtrace_t *libtrace)
    124124{
    125         libtrace->format_data = calloc(1,sizeof(struct wag_format_data_t));
     125        libtrace->format_data = calloc((size_t)1,
     126                                        sizeof(struct wag_format_data_t));
    126127        return 0;
    127128}
     
    216217        size_t framesize;
    217218        char *buf_ptr = (char *)buffer;
    218         unsigned int to_read = 0;
     219        size_t to_read = 0;
    219220        uint16_t magic = 0;
    220221        long fd_flags;
     
    295296       
    296297        while (to_read>0) {
    297                 int ret=read(INPUT.fd,buf_ptr,to_read);
     298                int ret=read(INPUT.fd,buf_ptr,(size_t)to_read);
    298299
    299300                if (ret == -1) {
     
    322323        if (packet->buf_control == TRACE_CTRL_EXTERNAL || !packet->buffer) {
    323324                packet->buf_control = TRACE_CTRL_PACKET;
    324                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     325                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    325326        }
    326327       
     
    330331       
    331332        if ((numbytes = wag_read(libtrace, (void *)packet->buffer,
    332                                         RP_BUFSIZE, block_flag)) <= 0) {
     333                                        (size_t)RP_BUFSIZE, block_flag)) <= 0) {
    333334           
    334335                return numbytes;
     
    354355        if (packet->buf_control == TRACE_CTRL_EXTERNAL || !packet->buffer) {
    355356                packet->buf_control = TRACE_CTRL_PACKET;
    356                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     357                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    357358        }
    358359        packet->type = TRACE_RT_DATA_WAG;
     
    385386        assert(size > 0);
    386387       
    387         if ((numbytes=libtrace_io_read(INPUT.file, buffer2, size)) != size) {
     388        if ((numbytes=libtrace_io_read(INPUT.file, buffer2, (size_t)size))
     389                                != size) {
    388390                trace_set_err(libtrace,
    389391                                errno,"read(%s,buffer)",packet->trace->uridata);
  • lib/libtrace.h.in

    r7dd71f0 r4bd8a5b  
    930930libtrace_ip_t *trace_get_ip(libtrace_packet_t *packet);
    931931
     932/** get a pointer to the IPv6 header (if any)
     933 * @param packet        the packet opaque pointer
     934 *
     935 * @return a pointer to the IPv6 header, or NULL if there is no IPv6 header
     936 */
     937DLLEXPORT SIMPLE_FUNCTION
     938libtrace_ip6_t *trace_get_ip6(libtrace_packet_t *packet);
     939
    932940/** Gets a pointer to the transport layer header (if any)
    933941 * @param packet        a pointer to a libtrace_packet structure
  • lib/libtrace_int.h

    r5d56d34 r4bd8a5b  
    112112#endif
    113113
    114 #define RP_BUFSIZE 65536
     114#define RP_BUFSIZE 65536U
    115115
    116116struct libtrace_event_status_t {
     
    134134                                            * doesn't support filters natively
    135135                                            */
    136         unsigned int snaplen;           /**< used by libtrace if the module
     136        size_t snaplen;         /**< used by libtrace if the module
    137137                                          * doesn't support snapping natively
    138138                                          */
     
    359359libtrace_rt_types_t pcap_dlt_to_rt(libtrace_dlt_t dlt);
    360360libtrace_dlt_t rt_to_pcap_dlt(libtrace_rt_types_t rt_type);
    361 libtrace_linktype_t erf_type_to_libtrace(char erf);
    362 char libtrace_to_erf_type(libtrace_linktype_t linktype);
     361libtrace_linktype_t erf_type_to_libtrace(uint8_t erf);
     362uint8_t libtrace_to_erf_type(libtrace_linktype_t linktype);
    363363libtrace_linktype_t arphrd_type_to_libtrace(unsigned int);
    364364unsigned int libtrace_to_arphrd_type(libtrace_linktype_t);
  • lib/libtraceio-zlib.c

    reecda9f r4bd8a5b  
    1010ssize_t libtrace_io_read(libtrace_io_t *io, void *buf, size_t len)
    1111{
    12         int err=gzread(io->file,buf,len);
     12        int err=gzread(io->file,buf,(unsigned) len);
    1313        int err2=errno;
    1414        if (err>=0) {
     
    6363ssize_t libtrace_io_write(libtrace_io_t *io, const void *buf, size_t len)
    6464{
    65         return (ssize_t)gzwrite(io->file,buf,len);
     65        return (ssize_t)gzwrite(io->file,buf,(unsigned)len);
    6666}
    6767
  • lib/link_wireless.c

    r73da4ae r4bd8a5b  
    6161        p = (uint8_t *) &(rtap->it_present);
    6262
    63         while ( bswap_le_to_host32(*((uint32_t*)p)) & (1 << TRACE_RADIOTAP_EXT) ) {
     63        while ( bswap_le_to_host32(*((uint32_t*)p)) & (1U << TRACE_RADIOTAP_EXT) ) {
    6464                p += sizeof (uint32_t);
    6565        }
  • lib/linktypes.c

    re7d66bf r4bd8a5b  
    101101}
    102102
    103 libtrace_linktype_t erf_type_to_libtrace(char erf)
     103libtrace_linktype_t erf_type_to_libtrace(uint8_t erf)
    104104{
    105105        switch (erf) {
     
    112112}
    113113
    114 char libtrace_to_erf_type(libtrace_linktype_t linktype)
     114uint8_t libtrace_to_erf_type(libtrace_linktype_t linktype)
    115115{
    116116        switch(linktype) {
     
    131131                        break;
    132132        }
    133         return -1;
     133        return 255;
    134134}
    135135
     
    261261                        memcpy(tmp+sizeof(libtrace_pcapfile_pkt_hdr_t),
    262262                                        packet->payload,
    263                                         remaining);
     263                                        (size_t)remaining);
    264264                        if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
    265265                                packet->buf_control=TRACE_CTRL_PACKET;
     
    300300                        memcpy(tmp+sizeof(libtrace_pcapfile_pkt_hdr_t),
    301301                                        packet->payload,
    302                                         remaining);
     302                                        (size_t)remaining);
    303303                        if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
    304304                                packet->buf_control=TRACE_CTRL_PACKET;
  • lib/trace.c

    r778d459 r4bd8a5b  
    224224                pcap_constructor();
    225225#endif
    226 #if HAVE_BIOCSETIF
     226#ifdef HAVE_BIOCSETIF
    227227                bpf_constructor();
    228228#endif
     
    252252}
    253253
    254 #define RP_BUFSIZE 65536
    255 #define URI_PROTO_LINE 16
     254#define URI_PROTO_LINE 16U
    256255
    257256
     
    375374                xstrncpy(scan, uri, strlen(uri));
    376375        } else {
    377                 xstrncpy(scan,uri, (uridata - uri));
     376                xstrncpy(scan,uri, (size_t)(uridata - uri));
    378377        }
    379378       
     
    606605{
    607606        libtrace_packet_t *packet =
    608                 (libtrace_packet_t*)calloc(1,sizeof(libtrace_packet_t));
     607                (libtrace_packet_t*)calloc((size_t)1,sizeof(libtrace_packet_t));
    609608        packet->buf_control=TRACE_CTRL_PACKET;
    610609        return packet;
     
    966965                }
    967966                pcap=(pcap_t *)pcap_open_dead(
    968                                 libtrace_to_pcap_dlt(linktype),
    969                                 1500);
     967                                (int)libtrace_to_pcap_dlt(linktype),
     968                                1500U);
    970969                /* build filter */
    971970                if (pcap_compile( pcap, &filter->filter, filter->filterstring,
     
    12341233        }
    12351234
    1236         *format=xstrndup(uri, (uridata - uri));
     1235        *format=xstrndup(uri, (size_t)(uridata - uri));
    12371236
    12381237        /* push uridata past the delimiter */
     
    13971396        if (!buf2)
    13981397                buf2=staticbuf;
    1399         snprintf(buf2,18,"%02x:%02x:%02x:%02x:%02x:%02x",
     1398        snprintf(buf2,(size_t)18,"%02x:%02x:%02x:%02x:%02x:%02x",
    14001399                        addr[0],addr[1],addr[2],
    14011400                        addr[3],addr[4],addr[5]);
     
    14471446        packet->payload=(void*)((char*)packet->buffer+sizeof(hdr));
    14481447        memcpy(packet->header,&hdr,sizeof(hdr));
    1449         memcpy(packet->payload,data,len);
     1448        memcpy(packet->payload,data,(size_t)len);
    14501449        packet->type=pcap_dlt_to_rt(libtrace_to_pcap_dlt(linktype));
    14511450}
Note: See TracChangeset for help on using the changeset viewer.