Changeset 33d83d4


Ignore:
Timestamp:
11/14/06 11:49:11 (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:
cab58c5
Parents:
b9aa767
Message:

Fixed up brazillions of warnings

Location:
lib
Files:
2 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    ra605bbe r33d83d4  
    2525                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
    2626                format_duck.c $(NATIVEFORMATS) $(BPFFORMATS) \
    27                 parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
     27                libtrace_int.h lt_inttypes.h \
    2828                linktypes.c protocols.c libtraceio.h link_wireless.c
    2929
  • lib/format_duck.c

    ra7d1914 r33d83d4  
    137137        int numbytes = 0;
    138138        uint32_t version = 0;
    139         int duck_size;
     139        unsigned int duck_size;
    140140       
    141141        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
     
    252252}
    253253
    254 static void duck_help() {
     254static void duck_help(void) {
    255255        printf("Endace DUCK format module\n");
    256256        printf("Supported input uris:\n");
     
    296296};
    297297
    298 void duck_constructor() {
     298void duck_constructor(void) {
    299299        register_format(&duck);
    300300}       
  • lib/format_erf.c

    r19c6cbe r33d83d4  
    3535#include "libtrace_int.h"
    3636#include "format_helper.h"
    37 #include "parse_cmd.h"
    3837
    3938#include <assert.h>
     
    626625static int erf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    627626        int numbytes;
    628         int size;
     627        unsigned int size;
    629628        void *buffer2 = packet->buffer;
    630         int rlen;
     629        unsigned int rlen;
    631630
    632631        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
     
    883882
    884883#ifdef HAVE_DAG
    885 libtrace_eventobj_t trace_event_dag(libtrace_t *trace, libtrace_packet_t *packet) {
     884static libtrace_eventobj_t trace_event_dag(libtrace_t *trace,
     885                                        libtrace_packet_t *packet) {
    886886        libtrace_eventobj_t event = {0,0,0.0,0};
    887887        int dag_fd;
     
    908908
    909909#ifdef HAVE_DAG
    910 static void dag_help() {
     910static void dag_help(void) {
    911911        printf("dag format module: $Revision$\n");
    912912        printf("Supported input URIs:\n");
     
    921921#endif
    922922
    923 static void erf_help() {
     923static void erf_help(void) {
    924924        printf("erf format module: $Revision$\n");
    925925        printf("Supported input URIs:\n");
     
    10171017#endif
    10181018
    1019 void erf_constructor() {
     1019void erf_constructor(void) {
    10201020        register_format(&erf);
    10211021#ifdef HAVE_DAG
  • lib/format_helper.c

    r3eff1c8 r33d83d4  
    6161#  include <sys/ioctl.h>
    6262
    63 struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
     63struct libtrace_eventobj_t trace_event_device(struct libtrace_t *trace,
     64                                        struct libtrace_packet_t *packet) {
    6465        struct libtrace_eventobj_t event = {0,0,0.0,0};
    6566        int data;
  • lib/format_legacy.c

    rf9d2f04 r33d83d4  
    3535#include "libtrace_int.h"
    3636#include "format_helper.h"
    37 #include "parse_cmd.h"
    3837
    3938#include <sys/stat.h>
     
    189188
    190189
    191 static void legacypos_help() {
     190static void legacypos_help(void) {
    192191        printf("legacypos format module: $Revision$\n");
    193192        printf("Supported input URIs:\n");
     
    200199}
    201200
    202 static void legacyatm_help() {
     201static void legacyatm_help(void) {
    203202        printf("legacyatm format module: $Revision$\n");
    204203        printf("Supported input URIs:\n");
     
    211210}
    212211
    213 static void legacyeth_help() {
     212static void legacyeth_help(void) {
    214213        printf("legacyeth format module: $Revision$\n");
    215214        printf("Supported input URIs:\n");
     
    328327
    329328       
    330 void legacy_constructor() {
     329void legacy_constructor(void) {
    331330        register_format(&legacypos);
    332331        register_format(&legacyeth);
  • lib/format_linux.c

    r3ed9a80 r33d83d4  
    365365}
    366366
    367 static void linuxnative_help() {
     367static void linuxnative_help(void) {
    368368        printf("linuxnative format module: $Revision$\n");
    369369        printf("Supported input URIs:\n");
     
    410410};
    411411
    412 void linuxnative_constructor() {
     412void linuxnative_constructor(void) {
    413413        register_format(&linuxnative);
    414414}
  • lib/format_pcap.c

    rd5e1796 r33d83d4  
    314314         * pop off the top header until it can be converted
    315315         */
    316         while (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0) {
     316        while (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0U) {
    317317                if (!demote_packet(packet)) {
    318318                        trace_set_err_out(libtrace,
     
    325325        if (!OUTPUT.trace.pcap) {
    326326                OUTPUT.trace.pcap = (pcap_t *)pcap_open_dead(
    327                         libtrace_to_pcap_dlt(trace_get_link_type(packet)),
     327                        (int)libtrace_to_pcap_dlt(trace_get_link_type(packet)),
    328328                        65536);
    329329                if (!OUTPUT.trace.pcap) {
     
    539539}
    540540
    541 static void pcap_help() {
     541static void pcap_help(void) {
    542542        printf("pcap format module: $Revision$\n");
    543543        printf("Supported input URIs:\n");
     
    551551}
    552552
    553 static void pcapint_help() {
     553static void pcapint_help(void) {
    554554        printf("pcapint format module: $Revision$\n");
    555555        printf("Supported input URIs:\n");
     
    634634};
    635635
    636 void pcap_constructor() {
     636void pcap_constructor(void) {
    637637        register_format(&pcap);
    638638        register_format(&pcapint);
  • lib/format_pcapfile.c

    r2f3a25e r33d83d4  
    267267         * pop off the top header until it can be converted
    268268         */
    269         while (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0) {
     269        while (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0U) {
    270270                if (!demote_packet(packet)) {
    271271                        trace_set_err_out(out,
     
    281281         */
    282282        if (!DATAOUT(out)->file) {
    283                 struct pcapfile_header_t hdr;
     283                struct pcapfile_header_t pcaphdr;
    284284
    285285                DATAOUT(out)->file=trace_open_file_out(out,
     
    289289                        return -1;
    290290
    291                 hdr.magic_number = 0xa1b2c3d4;
    292                 hdr.version_major = 2;
    293                 hdr.version_minor = 4;
    294                 hdr.thiszone = 0;
    295                 hdr.sigfigs = 0;
    296                 hdr.snaplen = 65536;
    297                 hdr.network =
     291                pcaphdr.magic_number = 0xa1b2c3d4;
     292                pcaphdr.version_major = 2;
     293                pcaphdr.version_minor = 4;
     294                pcaphdr.thiszone = 0;
     295                pcaphdr.sigfigs = 0;
     296                pcaphdr.snaplen = 65536;
     297                pcaphdr.network =
    298298                        libtrace_to_pcap_dlt(trace_get_link_type(packet));
    299299
    300                 libtrace_io_write(DATAOUT(out)->file, &hdr, sizeof(hdr));
     300                libtrace_io_write(DATAOUT(out)->file, &pcaphdr, sizeof(pcaphdr));
    301301        }
    302302
     
    451451}
    452452
    453 static void pcapfile_help() {
     453static void pcapfile_help(void) {
    454454        printf("pcapfile format module: $Revision$\n");
    455455        printf("Supported input URIs:\n");
     
    497497
    498498
    499 void pcapfile_constructor() {
     499void pcapfile_constructor(void) {
    500500        register_format(&pcapfile);
    501501}
  • lib/format_rt.c

    r85921e8 r33d83d4  
    3737#include "libtrace_int.h"
    3838#include "format_helper.h"
    39 #include "parse_cmd.h"
    4039#include "rt_protocol.h"
    4140
     
    5453#define RT_INFO ((struct rt_format_data_t*)libtrace->format_data)
    5554
    56 char *rt_deny_reason(uint8_t reason) {
     55static char *rt_deny_reason(uint8_t reason) {
    5756        char *string = 0;
    5857
     
    442441        char *buf_ptr;
    443442        int numbytes = 0;
    444         int to_write = 0;
     443        unsigned int to_write = 0;
    445444        rt_header_t *hdr;
    446445        rt_ack_t *ack_hdr;
     
    631630}
    632631
    633 libtrace_eventobj_t trace_event_rt(libtrace_t *trace, libtrace_packet_t *packet) {
     632static libtrace_eventobj_t trace_event_rt(libtrace_t *trace,
     633                                        libtrace_packet_t *packet)
     634{
    634635        libtrace_eventobj_t event = {0,0,0.0,0};
    635636        libtrace_err_t read_err;
     
    667668}
    668669
    669 static void rt_help() {
     670static void rt_help(void) {
    670671        printf("rt format module\n");
    671672        printf("Supported input URIs:\n");
     
    715716};
    716717
    717 void rt_constructor() {
     718void rt_constructor(void) {
    718719        register_format(&rt);
    719720}
  • lib/format_wag.c

    ra7d1914 r33d83d4  
    216216        size_t framesize;
    217217        char *buf_ptr = (char *)buffer;
    218         int to_read = 0;
     218        unsigned int to_read = 0;
    219219        uint16_t magic = 0;
    220220        long fd_flags;
     
    500500}
    501501
    502 struct libtrace_eventobj_t trace_event_wag(libtrace_t *trace, libtrace_packet_t *packet) {
     502static struct libtrace_eventobj_t trace_event_wag(libtrace_t *trace, libtrace_packet_t *packet)
     503{
    503504        struct libtrace_eventobj_t event = {0,0,0.0,0};
    504505        libtrace_err_t read_err;
     
    533534}
    534535       
    535 static void wag_help() {
     536static void wag_help(void) {
    536537        printf("wag format module: $Revision$\n");
    537538        printf("Supported input URIs:\n");
     
    545546}
    546547
    547 static void wtf_help() {
     548static void wtf_help(void) {
    548549        printf("wag trace format module: $Revision$\n");
    549550        printf("Supported input URIs:\n");
     
    634635
    635636
    636 void wag_constructor() {
     637void wag_constructor(void) {
    637638        register_format(&wag);
    638639        register_format(&wag_trace);
  • lib/libtrace_int.h

    ra605bbe r33d83d4  
    134134                                            * doesn't support filters natively
    135135                                            */
    136         int snaplen;                    /**< used by libtrace if the module
     136        unsigned int snaplen;           /**< used by libtrace if the module
    137137                                          * doesn't support snapping natively
    138138                                          */
     
    346346        struct libtrace_eventobj_t (*trace_event)(libtrace_t *trace, libtrace_packet_t *packet);       
    347347        /** return information about this trace format to standard out */
    348         void (*help)();
     348        void (*help)(void);
    349349        /** next pointer, should be NULL */
    350350        struct libtrace_format_t *next;
     
    368368
    369369void *trace_get_payload_from_linux_sll(void *, uint16_t *, uint32_t *);
     370void *trace_get_payload_from_pos(void *, uint16_t *, uint32_t *);
     371void *trace_get_payload_from_atm(void *, uint8_t *, uint32_t *);
    370372
    371373uint64_t byteswap64(uint64_t num);
  • lib/linktypes.c

    rf9d2f04 r33d83d4  
    4444                                         
    4545        }
    46         return ~0;
     46        return ~0U;
    4747}
    4848
     
    6969                         * include the ATM header, only the LLCSNAP header.
    7070                         */
    71                         return ~0;
     71                        return ~0U;
    7272                case TRACE_TYPE_LLCSNAP: return TRACE_DLT_ATM_RFC1483;
    7373        }
    74         return ~0;
     74        return ~0U;
    7575}
    7676
     
    9595                case TYPE_AAL5:         return TRACE_TYPE_AAL5;
    9696        }
    97         return ~0;
     97        return ~0U;
    9898}
    9999
     
    115115                case ARPHRD_80211_RADIOTAP: return TRACE_TYPE_80211_RADIO;
    116116        }
    117         return ~0;
     117        return ~0U;
    118118}
    119119
     
    124124                case TRACE_TYPE_80211_RADIO: return ARPHRD_80211_RADIOTAP;
    125125        }
    126         return -1;
     126        return ~0U;
    127127}
    128128
  • lib/protocols.c

    rbb75d10 r33d83d4  
    184184
    185185        if (type)
    186                 type=cell->pt;
     186                *type=cell->pt;
    187187
    188188        if (remaining)
     
    678678{
    679679        uint32_t remaining;
    680         struct ports_t *port =
    681                 (struct ports_t*)trace_get_transport((libtrace_packet_t*)packet,
     680        const struct ports_t *port =
     681                (const struct ports_t*)trace_get_transport((libtrace_packet_t*)packet,
    682682                        NULL, &remaining);
    683683
  • lib/trace.c

    rb9aa767 r33d83d4  
    212212}
    213213
    214 void erf_constructor();
    215 void legacy_constructor();
    216 void linuxnative_constructor();
    217 void pcap_constructor();
    218 void pcapfile_constructor();
    219 void rt_constructor();
    220 void wag_constructor();
    221 void duck_constructor();
     214void erf_constructor(void);
     215void legacy_constructor(void);
     216void linuxnative_constructor(void);
     217void pcap_constructor(void);
     218void pcapfile_constructor(void);
     219void rt_constructor(void);
     220void wag_constructor(void);
     221void duck_constructor(void);
    222222
    223223/* call all the constructors if they haven't yet all been called */
    224 void trace_init(void)
     224static void trace_init(void)
    225225{
    226226        if (!formats_list) {
     
    602602 * @author Shane Alcock
    603603 * */
    604 DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace) {
     604DLLEXPORT void trace_destroy_output(libtrace_out_t *libtrace)
     605{
    605606        assert(libtrace);
    606607        libtrace->format->fin_output(libtrace);
     
    609610}
    610611
    611 DLLEXPORT libtrace_packet_t *trace_create_packet() {
     612DLLEXPORT libtrace_packet_t *trace_create_packet(void)
     613{
    612614        libtrace_packet_t *packet =
    613615                (libtrace_packet_t*)calloc(1,sizeof(libtrace_packet_t));
     
    997999#ifdef HAVE_BPF
    9981000        void *linkptr = 0;
    999         int clen = 0;
     1001        unsigned int clen = 0;
    10001002        bool free_packet_needed = false;
    10011003        int ret;
     1004        libtrace_packet_t *packet_copy = packet;
     1005
    10021006        assert(filter);
    10031007        assert(packet);
    1004         libtrace_packet_t *packet_copy = packet;
    1005 
    1006        
    1007         if (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0) {
     1008
     1009        if (libtrace_to_pcap_dlt(trace_get_link_type(packet))==~0U) {
    10081010                /* Copy the packet, as we don't want to trash the one we
    10091011                 * were passed in
     
    10121014                free_packet_needed=true;
    10131015                while (libtrace_to_pcap_dlt(trace_get_link_type(packet_copy))==
    1014                                 ~0) {
     1016                                ~0U) {
    10151017                        if (!demote_packet(packet_copy)) {
    1016                                 trace_set_err_out(packet->trace,
     1018                                trace_set_err(packet->trace,
    10171019                                                TRACE_ERR_NO_CONVERSION,
    10181020                                                "pcap does not support this format");
Note: See TracChangeset for help on using the changeset viewer.