Changeset 85a79b0


Ignore:
Timestamp:
08/25/06 15:47:43 (14 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:
e283596
Parents:
e373992
Message:

Fixed lots of warnings

Location:
lib
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • lib/fifo.c

    r77285d9 r85a79b0  
    7272        /* Set up our fifo
    7373        */
    74         struct tracefifo_t *fifo = malloc(sizeof(struct tracefifo_t));
     74        struct tracefifo_t *fifo =
     75                (struct tracefifo_t*)malloc(sizeof(struct tracefifo_t));
    7576        assert(size > 0);
    7677
     
    106107}
    107108
    108 void tracefifo_flush(struct tracefifo_t *fifo UNUSED) {
     109void tracefifo_flush(UNUSED struct tracefifo_t *fifo) {
    109110        /* do nothing */
    110111        return;
  • lib/format_duck.c

    rc28b5c7 r85a79b0  
    4747#define INPUT DATA(libtrace)
    4848#define OUTPUT DATAOUT(libtrace)
    49 
    50 
    51 static struct libtrace_format_t duck;
    5249
    5350struct duck_format_data_t {
     
    202199
    203200static int duck_write_packet(libtrace_out_t *libtrace,
    204                                 const libtrace_packet_t *packet) {
     201                libtrace_packet_t *packet)
     202{
    205203
    206204        int numbytes = 0;
     
    228226        if ((numbytes = libtrace_io_write(OUTPUT->file, packet->payload,
    229227                                        trace_get_capture_length(packet))) !=
    230                                 trace_get_capture_length(packet)) {
     228                                (int)trace_get_capture_length(packet)) {
    231229                trace_set_err_out(libtrace, errno, "Writing DUCK failed");
    232230                return -1;
  • lib/format_legacy.c

    rc0cd256 r85a79b0  
    5656#  define O_LARGEFILE 0
    5757#endif
    58 
    59 static struct libtrace_format_t legacypos;
    60 static struct libtrace_format_t legacyeth;
    61 static struct libtrace_format_t legacyatm;
    6258
    6359#define DATA(x) ((struct legacy_format_data_t *)x->format_data)
  • lib/format_linux.c

    rc0cd256 r85a79b0  
    4949#include <net/if.h>
    5050#include <sys/ioctl.h>
    51 
    52 static struct libtrace_format_t linuxnative;
    5351
    5452struct libtrace_format_data_t {
     
    218216        packet->payload = (char*)packet->buffer+sizeof(*hdr);
    219217
    220         hdr=(void*)packet->buffer;
     218        hdr=(struct libtrace_linuxnative_header*)packet->buffer;
    221219        socklen=sizeof(hdr->hdr);
    222220        snaplen=LIBTRACE_MIN(
     
    227225                        snaplen,
    228226                        MSG_TRUNC,
    229                         (void *)&hdr->hdr,
     227                        (struct sockaddr *)&hdr->hdr,
    230228                        &socklen);
    231229
     
    242240
    243241static int linuxnative_write_packet(libtrace_out_t *trace,
    244                 const libtrace_packet_t *packet)
     242                libtrace_packet_t *packet)
    245243{
    246244        struct sockaddr_ll hdr;
     
    272270                default: /* shrug, beyond me! */
    273271                        printf("unknown type %x\n",linktype);
    274                         return -1;
     272                        return (libtrace_linktype_t)~0U;
    275273        }
    276274}
     
    300298}
    301299
    302 static int linuxnative_get_framing_length(const libtrace_packet_t *packet)
     300static int linuxnative_get_framing_length(UNUSED
     301                const libtrace_packet_t *packet)
    303302{
    304303        return sizeof(struct libtrace_linuxnative_header);
  • lib/format_pcap.c

    re373992 r85a79b0  
    181181        switch(option) {
    182182                case TRACE_OPTION_FILTER:
    183                         DATA(libtrace)->filter=data;
     183                        DATA(libtrace)->filter=(libtrace_filter_t*)data;
    184184                        return 0;
    185185                case TRACE_OPTION_SNAPLEN:
     
    306306}
    307307
    308 static int pcap_write_packet(libtrace_out_t *libtrace, const libtrace_packet_t *packet) {
     308static int pcap_write_packet(libtrace_out_t *libtrace,
     309                libtrace_packet_t *packet)
     310{
    309311        struct pcap_pkthdr pcap_pkt_hdr;
    310312
     
    366368}
    367369
    368 static int pcapint_write_packet(libtrace_out_t *libtrace, const libtrace_packet_t *packet) {
     370static int pcapint_write_packet(libtrace_out_t *libtrace,
     371                libtrace_packet_t *packet)
     372{
    369373        int err;
    370374
     
    498502}
    499503
    500 static int pcap_get_framing_length(const libtrace_packet_t *packet UNUSED) {
     504static int pcap_get_framing_length(UNUSED const libtrace_packet_t *packet) {
    501505        return sizeof(struct pcap_pkthdr);
    502506}
  • lib/format_rt.c

    rc0cd256 r85a79b0  
    9090        libtrace_t *dummy_linux;
    9191};
    92 
    93 static struct libtrace_format_t rt;
    9492
    9593static int rt_connect(libtrace_t *libtrace) {
  • lib/format_wag.c

    r8e6ac85 r85a79b0  
    5656#  include <io.h>
    5757#  include <share.h>
     58#else
     59#  include <sys/ioctl.h>
    5860#endif
    5961
     
    396398}                               
    397399       
    398 static int wtf_write_packet(libtrace_out_t *libtrace, const libtrace_packet_t *packet) {
     400static int wtf_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
     401{
    399402        int numbytes =0 ;
    400403        if (packet->trace->format != &wag_trace) {
     
    410413        if ((numbytes = libtrace_io_write(OUTPUT.file, packet->header,
    411414                                trace_get_framing_length(packet)))
    412                         !=trace_get_framing_length(packet)) {
     415                        !=(int)trace_get_framing_length(packet)) {
    413416                trace_set_err_out(libtrace,errno,
    414417                                "write(%s)",packet->trace->uridata);
     
    417420        if ((numbytes = libtrace_io_write(OUTPUT.file, packet->payload,
    418421                                trace_get_capture_length(packet))
    419                                 != trace_get_capture_length(packet))) {
     422                                != (int)trace_get_capture_length(packet))) {
    420423                trace_set_err_out(libtrace,
    421424                                errno,"write(%s)",packet->trace->uridata);
  • lib/libtraceio-zlib.c

    r46dd1e3 r85a79b0  
    55
    66struct libtrace_io_t {
    7         gzFile *file;
     7        gzFile file;
    88};
    99
     
    3535libtrace_io_t *libtrace_io_fdopen(int fd, const char *mode)
    3636{
    37         libtrace_io_t *io = malloc(sizeof(libtrace_io_t));
     37        libtrace_io_t *io = (libtrace_io_t*)malloc(sizeof(libtrace_io_t));
    3838        io->file = gzdopen(fd,mode);
    3939        return io;
     
    4242libtrace_io_t *libtrace_io_open(const char *path, const char *mode)
    4343{
    44         libtrace_io_t *io = malloc(sizeof(libtrace_io_t));
     44        libtrace_io_t *io = (libtrace_io_t*)malloc(sizeof(libtrace_io_t));
    4545        io->file = gzopen(path,mode);
    4646        return io;
  • lib/linktypes.c

    rdcbc330 r85a79b0  
    108108                        case TRACE_TYPE_ETH:
    109109                                /* This should be easy, just prepend the header */
    110                                 tmpbuffer= malloc(sizeof(libtrace_sll_header_t)
     110                                tmpbuffer= (char*)malloc(
     111                                                sizeof(libtrace_sll_header_t)
    111112                                                +trace_get_capture_length(packet)
    112113                                                +trace_get_framing_length(packet)
    113114                                                );
    114115
    115                                 hdr=(void*)((char*)tmpbuffer
     116                                hdr=(libtrace_sll_header_t*)((char*)tmpbuffer
    116117                                        +trace_get_framing_length(packet));
    117118
  • lib/protocols.c

    rc0fdf31 r85a79b0  
    640640                        struct sockaddr_in *addr4=(struct sockaddr_in*)addr;
    641641                        libtrace_ip_t *ip = (libtrace_ip_t*)l3;
    642                         ports = trace_get_payload_from_ip(ip,NULL,&remaining);
     642                        ports = (struct ports_t*)
     643                                trace_get_payload_from_ip(ip,NULL,&remaining);
    643644                        addr4->sin_family=AF_INET;
    644645                        if (ports && remaining>=sizeof(*ports))
     
    653654                        struct sockaddr_in6 *addr6=(struct sockaddr_in6*)addr;
    654655                        libtrace_ip6_t *ip6 = (libtrace_ip6_t*)l3;
    655                         ports = trace_get_payload_from_ip6(ip6,NULL,&remaining);
     656                        ports = (struct ports_t*)
     657                                trace_get_payload_from_ip6(ip6,NULL,&remaining);
    656658                        addr6->sin6_family=AF_INET6;
    657659                        if (ports && remaining>=sizeof(*ports))
  • lib/trace.c

    r4dfa44e r85a79b0  
    637637                free(packet->buffer);
    638638        }
    639         packet->buf_control='\0'; /* an "bad" value to force an assert
    640                                    * if this packet is ever reused
    641                                    */
     639        packet->buf_control=(buf_control_t)'\0';
     640                                /* an "bad" value to force an assert
     641                                 * if this packet is ever reused
     642                                 */
    642643        free(packet);
    643644}       
     
    685686        }
    686687        trace_set_err(libtrace,TRACE_ERR_UNSUPPORTED,"This format does not support reading packets\n");
    687         packet->size=-1;
    688         return -1;
     688        packet->size=~0U;
     689        return ~0U;
    689690}
    690691
     
    832833                return packet->trace->format->get_capture_length(packet);
    833834        }
    834         return -1;
     835        return ~0U;
    835836}
    836837       
     
    850851                return packet->trace->format->get_wire_length(packet);
    851852        }
    852         return -1;
     853        return ~0U;
    853854
    854855}
     
    867868                return packet->trace->format->get_framing_length(packet);
    868869        }
    869         return -1;
     870        return ~0U;
    870871}
    871872
     
    975976                        return -1;
    976977                }
    977                 if (libtrace_to_pcap_dlt(linktype) == ~0U) {
     978                if (libtrace_to_pcap_dlt(linktype) == -1) {
    978979                        trace_set_err(packet->trace,TRACE_ERR_BAD_PACKET,
    979980                                        "Unknown pcap equivilent linktype");
     
    10241025
    10251026        assert(filter->flag);
    1026         return bpf_filter(filter->filter.bf_insns, linkptr, clen, clen);
     1027        return bpf_filter(filter->filter.bf_insns,(u_char*)linkptr,clen,clen);
    10271028#else
    10281029        fprintf(stderr,"This version of libtrace does not have bpf filter support\n");
     
    10441045                return packet->trace->format->set_direction(packet,direction);
    10451046        }
    1046         return -1;
     1047        return (libtrace_direction_t)~0U;
    10471048}
    10481049
     
    10631064                return packet->trace->format->get_direction(packet);
    10641065        }
    1065         return -1;
     1066        return (libtrace_direction_t)~0U;
    10661067}
    10671068
     
    10791080 * @param dest the TCP or UDP destination port
    10801081 * @returns a hint as to which port is the server port
    1081  * @author Daniel Lawson
    1082  */
    1083 DLLEXPORT int8_t trace_get_server_port(uint8_t protocol UNUSED, uint16_t source, uint16_t dest) {
     1082 */
     1083DLLEXPORT int8_t trace_get_server_port(UNUSED uint8_t protocol,
     1084                uint16_t source, uint16_t dest)
     1085{
    10841086        /*
    10851087         * * If the ports are equal, return DEST
     
    12031205        }
    12041206
    1205         return -1;
     1207        return ~0U;
    12061208}
    12071209
Note: See TracChangeset for help on using the changeset viewer.