From f3648fc66db36719b5bf4cc4a35ac45326153d20 Mon Sep 17 00:00:00 2001 From: Jeff Morriss Date: Thu, 21 Oct 2010 00:54:58 +0000 Subject: [PATCH] Fix up indentation to get it consistent and other minor cleanup issues. svn path=/trunk/; revision=34598 --- epan/wslua/wslua_dumper.c | 309 ++++++++++++++++++++------------------ 1 file changed, 163 insertions(+), 146 deletions(-) diff --git a/epan/wslua/wslua_dumper.c b/epan/wslua/wslua_dumper.c index 358dde2418..7fc5a4a49a 100644 --- a/epan/wslua/wslua_dumper.c +++ b/epan/wslua/wslua_dumper.c @@ -33,8 +33,8 @@ WSLUA_CLASS_DEFINE(PseudoHeader,NOP,NOP); /* - A pseudoheader to be used to save captured frames. - */ + * A pseudoheader to be used to save captured frames. + */ enum lua_pseudoheader_type { PHDR_NONE, @@ -54,45 +54,50 @@ enum lua_pseudoheader_type { struct lua_pseudo_header { enum lua_pseudoheader_type type; - union wtap_pseudo_header* wph; + union wtap_pseudo_header *wph; }; -WSLUA_CONSTRUCTOR PseudoHeader_none(lua_State* L) { - /* - Creates a "no" pseudoheader. - - */ +WSLUA_CONSTRUCTOR +PseudoHeader_none(lua_State *L) +{ + /* + * Creates a "no" pseudoheader. + * + */ + PseudoHeader ph = g_malloc(sizeof(struct lua_pseudo_header)); ph->type = PHDR_NONE; ph->wph = NULL; - + pushPseudoHeader(L,ph); - - WSLUA_RETURN(1); - /* A null pseudoheader */ + WSLUA_RETURN(1); /* A null pseudoheader */ } -WSLUA_CONSTRUCTOR PseudoHeader_eth(lua_State* L) { - /* - Creates an ethernet pseudoheader - */ +WSLUA_CONSTRUCTOR +PseudoHeader_eth(lua_State *L) +{ + /* + * Creates an ethernet pseudoheader + */ #define WSLUA_OPTARG_PseudoHeader_eth_FCSLEN 1 /* The fcs length */ - + PseudoHeader ph = g_malloc(sizeof(struct lua_pseudo_header)); ph->type = PHDR_ETH; ph->wph = g_malloc(sizeof(union wtap_pseudo_header)); ph->wph->eth.fcs_len = luaL_optint(L,WSLUA_OPTARG_PseudoHeader_eth_FCSLEN,-1); - + pushPseudoHeader(L,ph); - - WSLUA_RETURN(1); /* The ethernet pseudoheader */ + + WSLUA_RETURN(1); /* The ethernet pseudoheader */ } -WSLUA_CONSTRUCTOR PseudoHeader_atm(lua_State* L) { - /* - Creates an ATM pseudoheader - */ +WSLUA_CONSTRUCTOR +PseudoHeader_atm(lua_State *L) +{ + /* + * Creates an ATM pseudoheader + */ #define WSLUA_OPTARG_PseudoHeader_atm_AAL 1 /* AAL number */ #define WSLUA_OPTARG_PseudoHeader_atm_VPI 2 /* VPI */ #define WSLUA_OPTARG_PseudoHeader_atm_VCI 3 /* VCI */ @@ -111,14 +116,15 @@ WSLUA_CONSTRUCTOR PseudoHeader_atm(lua_State* L) { ph->wph->atm.cells = luaL_optint(L,WSLUA_OPTARG_PseudoHeader_atm_CELLS,1); ph->wph->atm.aal5t_u2u = luaL_optint(L,WSLUA_OPTARG_PseudoHeader_atm_AAL5U2U,1); ph->wph->atm.aal5t_len = luaL_optint(L,WSLUA_OPTARG_PseudoHeader_atm_AAL5LEN,0); - + pushPseudoHeader(L,ph); - WSLUA_RETURN(1); - /* The ATM pseudoheader */ + WSLUA_RETURN(1); /* The ATM pseudoheader */ } -WSLUA_CONSTRUCTOR PseudoHeader_mtp2(lua_State* L) { - /* Creates an MTP2 PseudoHeader */ +WSLUA_CONSTRUCTOR +PseudoHeader_mtp2(lua_State *L) +{ + /* Creates an MTP2 PseudoHeader */ #define WSLUA_OPTARG_PseudoHeader_mtp2_SENT 1 /* True if the packet is sent, False if received. */ #define WSLUA_OPTARG_PseudoHeader_mtp2_ANNEXA 2 /* True if annex A is used */ #define WSLUA_OPTARG_PseudoHeader_mtp2_LINKNUM 3 /* Link Number */ @@ -130,18 +136,18 @@ WSLUA_CONSTRUCTOR PseudoHeader_mtp2(lua_State* L) { ph->wph->mtp2.link_number = luaL_optint(L,WSLUA_OPTARG_PseudoHeader_mtp2_LINKNUM,0); pushPseudoHeader(L,ph); - WSLUA_RETURN(1); /* The MTP2 pseudoheader */ + WSLUA_RETURN(1); /* The MTP2 pseudoheader */ } #if 0 -static int PseudoHeader_x25(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_isdn(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_ascend(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_wifi(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_cosine(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_irda(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_nettl(lua_State* L) { luaL_error(L,"not implemented"); return 0; } -static int PseudoHeader_k12(lua_State* L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_x25(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_isdn(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_ascend(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_wifi(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_cosine(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_irda(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_nettl(lua_State *L) { luaL_error(L,"not implemented"); return 0; } +static int PseudoHeader_k12(lua_State *L) { luaL_error(L,"not implemented"); return 0; } #endif WSLUA_METHODS PseudoHeader_methods[] = { @@ -156,24 +162,28 @@ WSLUA_META PseudoHeader_meta[] = { {0,0} }; -int PseudoHeader_register(lua_State* L) { - WSLUA_REGISTER_CLASS(PseudoHeader) +int +PseudoHeader_register(lua_State *L) +{ + WSLUA_REGISTER_CLASS(PseudoHeader) return 0; } WSLUA_CLASS_DEFINE(Dumper,FAIL_ON_NULL("Dumper already closed"),NOP); -static GHashTable* dumper_encaps = NULL; +static GHashTable *dumper_encaps = NULL; #define DUMPER_ENCAP(d) GPOINTER_TO_INT(g_hash_table_lookup(dumper_encaps,d)) -static const char* cross_plat_fname(const char* fname) { +static const char* +cross_plat_fname(const char *fname) +{ static char fname_clean[256]; - char* f; + char *f; strncpy(fname_clean,fname,256); - for(f = fname_clean; *f; f++) { + for (f = fname_clean; *f; f++) { switch(*f) { case '/': case '\\': *f = *(G_DIR_SEPARATOR_S); @@ -182,182 +192,187 @@ static const char* cross_plat_fname(const char* fname) { break; } } - + return fname_clean; } -WSLUA_CONSTRUCTOR Dumper_new(lua_State* L) { - /* - Creates a file to write packets. - Dumper:new_for_current() will probably be a better choice. - */ +WSLUA_CONSTRUCTOR +Dumper_new(lua_State *L) +{ + /* + * Creates a file to write packets. + * Dumper:new_for_current() will probably be a better choice. + */ #define WSLUA_ARG_Dumper_new_FILENAME 1 /* The name of the capture file to be created */ #define WSLUA_OPTARG_Dumper_new_FILETYPE 2 /* The type of the file to be created */ #define WSLUA_OPTARG_Dumper_new_ENCAP 3 /* The encapsulation to be used in the file to be created */ Dumper d; - const char* fname = luaL_checkstring(L,WSLUA_ARG_Dumper_new_FILENAME); + const char *fname = luaL_checkstring(L,WSLUA_ARG_Dumper_new_FILENAME); int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_FILETYPE,WTAP_FILE_PCAP); int encap = luaL_optint(L,WSLUA_OPTARG_Dumper_new_ENCAP,WTAP_ENCAP_ETHERNET); int err = 0; - const char* filename; - + const char *filename; + if (! fname) return 0; - - filename = cross_plat_fname(fname); - + + filename = cross_plat_fname(fname); + if (!wtap_dump_can_write_encap(filetype, encap)) WSLUA_ERROR(Dumper_new,"Not every filetype handles every encap"); - + d = wtap_dump_open(filename, filetype, encap,0 , FALSE, &err); - + if (! d ) { - /* WSLUA_ERROR("Error while opening file for writing"); */ - luaL_error(L,"error while opening `%s': %s", - filename, + /* WSLUA_ERROR("Error while opening file for writing"); */ + luaL_error(L,"error while opening `%s': %s", filename, wtap_strerror(err)); return 0; } - + g_hash_table_insert(dumper_encaps,d,GINT_TO_POINTER(encap)); - + pushDumper(L,d); - WSLUA_RETURN(1); - /* The newly created Dumper object */ + WSLUA_RETURN(1); /* The newly created Dumper object */ } -WSLUA_METHOD Dumper_close(lua_State* L) { - /* Closes a dumper */ - Dumper* dp = (Dumper*)luaL_checkudata(L, 1, "Dumper"); +WSLUA_METHOD +Dumper_close(lua_State *L) +{ + /* Closes a dumper */ + Dumper *dp = (Dumper*)luaL_checkudata(L, 1, "Dumper"); int err; - - if (! *dp) - WSLUA_ERROR(Dumper_close,"Cannot operate on a closed dumper"); - g_hash_table_remove(dumper_encaps,*dp); + if (! *dp) + WSLUA_ERROR(Dumper_close,"Cannot operate on a closed dumper"); + + g_hash_table_remove(dumper_encaps, *dp); if (!wtap_dump_close(*dp, &err)) { - luaL_error(L,"error closing: %s", - wtap_strerror(err)); + luaL_error(L,"error closing: %s", wtap_strerror(err)); } - /* this way if we close a dumper any attempt to use it (for everything but GC) will yield an error */ - *dp = NULL; + /* this way if we close a dumper any attempt to use it (for everything but GC) will yield an error */ + *dp = NULL; return 0; } -WSLUA_METHOD Dumper_flush(lua_State* L) { - /* - Writes all unsaved data of a dumper to the disk. - */ +WSLUA_METHOD +Dumper_flush(lua_State *L) +{ + /* + * Writes all unsaved data of a dumper to the disk. + */ Dumper d = checkDumper(L,1); if (!d) return 0; - + wtap_dump_flush(d); - + return 0; } -WSLUA_METHOD Dumper_dump(lua_State* L) { - /* - Dumps an arbitrary packet. - Note: Dumper:dump_current() will fit best in most cases. - */ +WSLUA_METHOD +Dumper_dump(lua_State *L) +{ + /* + * Dumps an arbitrary packet. + * Note: Dumper:dump_current() will fit best in most cases. + */ #define WSLUA_ARG_Dumper_dump_TIMESTAMP 2 /* The absolute timestamp the packet will have */ #define WSLUA_ARG_Dumper_dump_PSEUDOHEADER 3 /* The Pseudoheader to use. */ #define WSLUA_ARG_Dumper_dump_BYTEARRAY 4 /* the data to be saved */ - Dumper d = checkDumper(L,1); + Dumper d = checkDumper(L,1); PseudoHeader ph; ByteArray ba; struct wtap_pkthdr pkthdr; double ts; int err; - + if (!d) return 0; - + ts = luaL_checknumber(L,WSLUA_ARG_Dumper_dump_TIMESTAMP); ph = checkPseudoHeader(L,WSLUA_ARG_Dumper_dump_PSEUDOHEADER); - + if (!ph) WSLUA_ARG_ERROR(Dumper_dump,TIMESTAMP,"need a PseudoHeader"); - + ba = checkByteArray(L,WSLUA_ARG_Dumper_dump_BYTEARRAY); - - if (! ba) WSLUA_ARG_ERROR(Dumper_dump,BYTEARRAY,"must be a ByteArray"); - - pkthdr.ts.secs = (unsigned)floor(ts); - pkthdr.ts.nsecs = (unsigned)floor((ts - (double)pkthdr.ts.secs) * 1000000000); + + if (! ba) WSLUA_ARG_ERROR(Dumper_dump,BYTEARRAY,"must be a ByteArray"); + + pkthdr.ts.secs = (unsigned)floor(ts); + pkthdr.ts.nsecs = (unsigned)floor((ts - (double)pkthdr.ts.secs) * 1000000000); pkthdr.len = ba->len; - pkthdr.caplen = ba->len; + pkthdr.caplen = ba->len; pkthdr.pkt_encap = DUMPER_ENCAP(d); - + if (! wtap_dump(d, &pkthdr, ph->wph, ba->data, &err)) { - luaL_error(L,"error while dumping: %s", - wtap_strerror(err)); + luaL_error(L,"error while dumping: %s", wtap_strerror(err)); } - + return 0; - } -WSLUA_METHOD Dumper_new_for_current(lua_State* L) { - /* - Creates a capture file using the same encapsulation as the one of the cuurrent packet - */ +WSLUA_METHOD +Dumper_new_for_current(lua_State *L) +{ + /* + * Creates a capture file using the same encapsulation as the one of the cuurrent packet + */ #define WSLUA_OPTARG_Dumper_new_for_current_FILETYPE 2 /* The file type. Defaults to pcap. */ - Dumper d; - const char* fname = luaL_checkstring(L,1); + Dumper d; + const char *fname = luaL_checkstring(L,1); int filetype = luaL_optint(L,WSLUA_OPTARG_Dumper_new_for_current_FILETYPE,WTAP_FILE_PCAP); int encap; int err = 0; - const char* filename; - + const char *filename; + if (! fname) return 0; - - filename = cross_plat_fname(fname); - + + filename = cross_plat_fname(fname); + if (! lua_pinfo ) - WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector"); - + WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector"); + encap = lua_pinfo->fd->lnk_t; - + if (!wtap_dump_can_write_encap(filetype, encap)) { luaL_error(L,"Cannot write encap %s in filetype %s", wtap_encap_short_string(encap), wtap_file_type_string(filetype)); return 0; } - + d = wtap_dump_open(filename, filetype, encap, 0 , FALSE, &err); - if (! d ) { + if (! d) { luaL_error(L,"error while opening `%s': %s", - filename, - wtap_strerror(err)); + filename, wtap_strerror(err)); return 0; } - + pushDumper(L,d); WSLUA_RETURN(1); /* The newly created Dumper Object */ - } -WSLUA_METHOD Dumper_dump_current(lua_State* L) { - /* - Dumps the current packet as it is. - */ +WSLUA_METHOD +Dumper_dump_current(lua_State *L) +{ + /* + * Dumps the current packet as it is. + */ Dumper d = checkDumper(L,1); struct wtap_pkthdr pkthdr; - const guchar* data; - tvbuff_t* tvb; + const guchar *data; + tvbuff_t *tvb; data_source *data_src; int err = 0; - + if (!d) return 0; - - if (! lua_pinfo ) WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector"); + + if (! lua_pinfo ) WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector"); data_src = (data_source*) (lua_pinfo->data_src->data); if (!data_src) @@ -372,29 +387,29 @@ WSLUA_METHOD Dumper_dump_current(lua_State* L) { pkthdr.pkt_encap = lua_pinfo->fd->lnk_t; data = ep_tvb_memdup(tvb,0,pkthdr.caplen); - + if (! wtap_dump(d, &pkthdr, lua_pinfo->pseudo_header, data, &err)) { - luaL_error(L,"error while dumping: %s", - wtap_strerror(err)); + luaL_error(L,"error while dumping: %s", wtap_strerror(err)); } return 0; } -static int Dumper__gc(lua_State* L) { - Dumper* dp = (Dumper*)luaL_checkudata(L, 1, "Dumper"); +static int +Dumper__gc(lua_State *L) +{ + Dumper *dp = (Dumper*)luaL_checkudata(L, 1, "Dumper"); int err; - /* If we are Garbage Collected it means the Dumper is no longer usable. Close it */ - - if (! *dp) - return 0; /* already closed, nothing to do! */ + /* If we are Garbage Collected it means the Dumper is no longer usable. Close it */ - g_hash_table_remove(dumper_encaps,*dp); + if (! *dp) + return 0; /* already closed, nothing to do! */ + + g_hash_table_remove(dumper_encaps, *dp); if (!wtap_dump_close(*dp, &err)) { - luaL_error(L,"error closing: %s", - wtap_strerror(err)); + luaL_error(L,"error closing: %s", wtap_strerror(err)); } return 0; @@ -412,11 +427,13 @@ WSLUA_METHODS Dumper_methods[] = { }; WSLUA_META Dumper_meta[] = { - {"__gc", Dumper__gc}, + {"__gc", Dumper__gc}, {0, 0} }; -int Dumper_register(lua_State* L) { +int +Dumper_register(lua_State *L) +{ dumper_encaps = g_hash_table_new(g_direct_hash,g_direct_equal); WSLUA_REGISTER_CLASS(Dumper); return 1;