epan/wslua/wslua_dumper.c

   1 /*
   2  *  wslua_dumper.c
   3  *
   4  * Wireshark's interface to the Lua Programming Language
   5  *
   6  * (c) 2006, Luis E. Garcia Ontanon <luis@ontanon.org>
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * SPDX-License-Identifier: GPL-2.0-or-later
  13  */
  14
  15 #include "config.h"
  16
  17 #include <wiretap/wtap_opttypes.h>
  18 #include <epan/wmem_scopes.h>
  19
  20 /* WSLUA_MODULE Dumper Saving Capture Files
  21
  22    The classes/functions defined in this module are for using a `Dumper` object to
  23    make Wireshark save a capture file to disk. `Dumper` represents Wireshark's built-in
  24    file format writers (see the `wtap_name_to_file_type_subtype` function).
  25
  26    (The `wtap_filetypes` table is deprecated, and should
  27    only be used in code that must run on Wireshark 3.4.3 and earlier 3.4
  28    releases or in Wireshark 3.2.11 and earlier 3.2.x releases.)
  29
  30    To have a Lua script create its own file format writer, see the chapter titled
  31    "Custom file format reading/writing".
  32 */
  33
  34 #include "wslua.h"
  35 #include <math.h>
  36
  37 WSLUA_CLASS_DEFINE(PseudoHeader,NOP);
  38 /*
  39  A pseudoheader to be used to save captured frames.
  40  */
  41
  42 enum lua_pseudoheader_type {
  43     PHDR_NONE,
  44     PHDR_ETH,
  45     PHDR_X25,
  46     PHDR_ISDN,
  47     PHDR_ATM,
  48     PHDR_ASCEND,
  49     PHDR_P2P,
  50     PHDR_WIFI,
  51     PHDR_COSINE,
  52     PHDR_IRDA,
  53     PHDR_NETTL,
  54     PHDR_MTP2,
  55     PHDR_K12
  56 };
  57
  58 struct lua_pseudo_header {
  59     enum lua_pseudoheader_type type;
  60     union wtap_pseudo_header* wph;
  61 };
  62
  63 WSLUA_CONSTRUCTOR PseudoHeader_none(lua_State* L) {
  64     /*
  65      Creates a "no" pseudoheader.
  66
  67     */
  68     PseudoHeader ph = (PseudoHeader)g_malloc(sizeof(struct lua_pseudo_header));
  69     ph->type = PHDR_NONE;
  70     ph->wph = NULL;
  71
  72     pushPseudoHeader(L,ph);
  73
  74     WSLUA_RETURN(1);
  75     /* A null pseudoheader */
  76 }
  77
  78 WSLUA_CONSTRUCTOR PseudoHeader_eth(lua_State* L) {
  79     /*
  80      Creates an ethernet pseudoheader.
  81      */
  82
  83 #define WSLUA_OPTARG_PseudoHeader_eth_FCSLEN 1 /* The fcs length */
  84
  85     PseudoHeader ph = (PseudoHeader)g_malloc(sizeof(struct lua_pseudo_header));
  86     ph->type = PHDR_ETH;
  87     ph->wph = (union wtap_pseudo_header *)g_malloc(sizeof(union wtap_pseudo_header));
  88     ph->wph->eth.fcs_len = (int)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_eth_FCSLEN,-1);
  89
  90     pushPseudoHeader(L,ph);
  91
  92     WSLUA_RETURN(1); /* The ethernet pseudoheader */
  93 }
  94
  95 WSLUA_CONSTRUCTOR PseudoHeader_atm(lua_State* L) {
  96     /*
  97      Creates an ATM pseudoheader.
  98      */
  99 #define WSLUA_OPTARG_PseudoHeader_atm_AAL 1 /* AAL number */
 100 #define WSLUA_OPTARG_PseudoHeader_atm_VPI 2 /* VPI */
 101 #define WSLUA_OPTARG_PseudoHeader_atm_VCI 3 /* VCI */
 102 #define WSLUA_OPTARG_PseudoHeader_atm_CHANNEL 4 /* Channel */
 103 #define WSLUA_OPTARG_PseudoHeader_atm_CELLS 5 /* Number of cells in the PDU */
 104 #define WSLUA_OPTARG_PseudoHeader_atm_AAL5U2U 6 /* AAL5 User to User indicator */
 105 #define WSLUA_OPTARG_PseudoHeader_atm_AAL5LEN 7 /* AAL5 Len */
 106
 107     PseudoHeader ph = (PseudoHeader)g_malloc(sizeof(struct lua_pseudo_header));
 108     ph->type = PHDR_ATM;
 109     ph->wph = (union wtap_pseudo_header *)g_malloc(sizeof(union wtap_pseudo_header));
 110     ph->wph->atm.aal = (uint8_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_AAL,5);
 111     ph->wph->atm.vpi = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_VPI,1);
 112     ph->wph->atm.vci = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_VCI,1);
 113     ph->wph->atm.channel = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_CHANNEL,0);
 114     ph->wph->atm.cells = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_CELLS,1);
 115     ph->wph->atm.aal5t_u2u = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_AAL5U2U,1);
 116     ph->wph->atm.aal5t_len = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_atm_AAL5LEN,0);
 117
 118     pushPseudoHeader(L,ph);
 119     WSLUA_RETURN(1);
 120     /* The ATM pseudoheader */
 121 }
 122
 123 WSLUA_CONSTRUCTOR PseudoHeader_mtp2(lua_State* L) {
 124     /* Creates an MTP2 PseudoHeader. */
 125 #define WSLUA_OPTARG_PseudoHeader_mtp2_SENT 1 /* True if the packet is sent, False if received. */
 126 #define WSLUA_OPTARG_PseudoHeader_mtp2_ANNEXA 2 /* True if annex A is used.  */
 127 #define WSLUA_OPTARG_PseudoHeader_mtp2_LINKNUM 3 /* Link Number. */
 128     PseudoHeader ph = (PseudoHeader)g_malloc(sizeof(struct lua_pseudo_header));
 129     ph->type = PHDR_MTP2;
 130     ph->wph = (union wtap_pseudo_header *)g_malloc(sizeof(union wtap_pseudo_header));
 131     ph->wph->mtp2.sent = (uint8_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_mtp2_SENT,0);
 132     ph->wph->mtp2.annex_a_used = (uint8_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_mtp2_ANNEXA,0);
 133     ph->wph->mtp2.link_number = (uint16_t)luaL_optinteger(L,WSLUA_OPTARG_PseudoHeader_mtp2_LINKNUM,0);
 134
 135     pushPseudoHeader(L,ph);
 136     WSLUA_RETURN(1); /* The MTP2 pseudoheader */
 137 }
 138
 139 #if 0
 140 static int PseudoHeader_x25(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 141 static int PseudoHeader_isdn(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 142 static int PseudoHeader_ascend(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 143 static int PseudoHeader_wifi(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 144 static int PseudoHeader_cosine(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 145 static int PseudoHeader_irda(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 146 static int PseudoHeader_nettl(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 147 static int PseudoHeader_k12(lua_State* L) { luaL_error(L,"not implemented"); return 0; }
 148 #endif
 149
 150 /* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
 151 static int PseudoHeader__gc(lua_State* L _U_) {
 152     /* do NOT free PseudoHeader */
 153     return 0;
 154 }
 155
 156 WSLUA_METHODS PseudoHeader_methods[] = {
 157     WSLUA_CLASS_FNREG(PseudoHeader,mtp2),
 158     WSLUA_CLASS_FNREG(PseudoHeader,atm),
 159     WSLUA_CLASS_FNREG(PseudoHeader,eth),
 160     WSLUA_CLASS_FNREG(PseudoHeader,none),
 161     {0,0}
 162 };
 163
 164 WSLUA_META PseudoHeader_meta[] = {
 165     {0,0}
 166 };
 167
 168 int PseudoHeader_register(lua_State* L) {
 169     WSLUA_REGISTER_CLASS(PseudoHeader)
 170     return 0;
 171 }
 172
 173
 174 WSLUA_CLASS_DEFINE(Dumper,FAIL_ON_NULL("Dumper already closed"));
 175
 176 static GHashTable* dumper_encaps;
 177 #define DUMPER_ENCAP(d) GPOINTER_TO_INT(g_hash_table_lookup(dumper_encaps,d))
 178
 179 static const char* cross_plat_fname(const char* fname) {
 180     static char fname_clean[256];
 181     char* f;
 182
 183     (void) g_strlcpy(fname_clean,fname,255);
 184     fname_clean[255] = '\0';
 185
 186     for(f = fname_clean; *f; f++) {
 187         switch(*f) {
 188             case '/': case '\\':
 189                 *f = *(G_DIR_SEPARATOR_S);
 190                 break;
 191             default:
 192                 break;
 193         }
 194     }
 195
 196     return fname_clean;
 197 }
 198
 199 WSLUA_CONSTRUCTOR Dumper_new(lua_State* L) {
 200     /*
 201      Creates a file to write packets.
 202      `Dumper:new_for_current()` will probably be a better choice, especially for file types other than pcapng.
 203     */
 204 #define WSLUA_ARG_Dumper_new_FILENAME 1 /* The name of the capture file to be created. */
 205 #define WSLUA_OPTARG_Dumper_new_FILETYPE 2 /* The type of the file to be created - a number returned by `wtap_name_to_file_type_subtype()`. Defaults to pcapng.
 206                                               (The `wtap_filetypes` table
 207                                               is deprecated, and should only be used
 208                                               in code that must run on Wireshark 3.4.3 and earlier 3.4.x releases
 209                                               or in Wireshark 3.2.11 and earlier
 210                                               3.2.x releases.) */
 211 #define WSLUA_OPTARG_Dumper_new_ENCAP 3 /* The encapsulation to be used in the file to be created - a number entry from the `wtap_encaps` table.
 212                                               Defaults to per-packet encapsulation for pcapng
 213                                               (which doesn't have file-level encapsulation;
 214                                               this will create IDBs on demand as necessary)
 215                                               and Ethernet encapsulation for other file types. */
 216     Dumper d;
 217     const char* fname = luaL_checkstring(L,WSLUA_ARG_Dumper_new_FILENAME);
 218     int filetype = (int)luaL_optinteger(L,WSLUA_OPTARG_Dumper_new_FILETYPE,wtap_pcapng_file_type_subtype());
 219     /* If we're writing pcapng, then WTAP_ENCAP_NONE and WTAP_ENCAP_PER_PACKET
 220      * generate a fake IDB on demand when the first packet for an encapsulation
 221      * type is written. Specifying any other encapsulation will generate a fake
 222      * IDB for that encapsulation upon opening even if there are no packets of
 223      * that type.
 224      * XXX - Default to PER_PACKET for any file type that supports it? */
 225     int encap  = (int)luaL_optinteger(L,WSLUA_OPTARG_Dumper_new_ENCAP, filetype == wtap_pcapng_file_type_subtype() ? WTAP_ENCAP_PER_PACKET : WTAP_ENCAP_ETHERNET);
 226     int err = 0;
 227     char *err_info = NULL;
 228     const char* filename = cross_plat_fname(fname);
 229     wtap_dump_params params = WTAP_DUMP_PARAMS_INIT;
 230
 231     params.encap = encap;
 232     /* XXX - Check for an existing file, or the same file name as the current
 233      * capture file?
 234      */
 235     d = wtap_dump_open(filename, filetype, WTAP_UNCOMPRESSED, &params, &err,
 236                        &err_info);
 237
 238     if (! d ) {
 239         /* WSLUA_ERROR("Error while opening file for writing"); */
 240         switch (err) {
 241         case WTAP_ERR_NOT_REGULAR_FILE:
 242             luaL_error(L,"The file \"%s\" is a \"special file\" or socket or other non-regular file",
 243                        filename);
 244             break;
 245
 246         case WTAP_ERR_CANT_WRITE_TO_PIPE:
 247             luaL_error(L,"The file \"%s\" is a pipe, and %s capture files can't be written to a pipe",
 248                        filename, wtap_file_type_subtype_description(filetype));
 249             break;
 250
 251         case WTAP_ERR_UNWRITABLE_FILE_TYPE:
 252             luaL_error(L,"Files of file type %s cannot be written",
 253                        wtap_file_type_subtype_description(filetype));
 254             break;
 255
 256         case WTAP_ERR_UNWRITABLE_ENCAP:
 257             luaL_error(L,"Files of file type %s don't support encapsulation %s",
 258                        wtap_file_type_subtype_description(filetype),
 259                        wtap_encap_name(encap));
 260             break;
 261
 262         case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
 263             luaL_error(L,"Files of file type %s don't support per-packet encapsulation",
 264                        wtap_file_type_subtype_description(filetype));
 265             break;
 266
 267         case WTAP_ERR_CANT_OPEN:
 268             luaL_error(L,"The file \"%s\" could not be created for some unknown reason",
 269                        filename);
 270             break;
 271
 272         case WTAP_ERR_SHORT_WRITE:
 273             luaL_error(L,"A full header couldn't be written to the file \"%s\".",
 274                        filename);
 275             break;
 276
 277         case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
 278             luaL_error(L,"Files of file type %s cannot be written as a compressed file",
 279                        wtap_file_type_subtype_description(filetype));
 280             break;
 281
 282         case WTAP_ERR_INTERNAL:
 283             luaL_error(L,"An internal error occurred creating the file \"%s\" (%s)",
 284                        filename,
 285                        err_info != NULL ? err_info : "no information supplied");
 286             g_free(err_info);
 287             break;
 288
 289         default:
 290             luaL_error(L,"error while opening \"%s\": %s",
 291                        filename,
 292                        wtap_strerror(err));
 293             break;
 294         }
 295         return 0;
 296     }
 297
 298     g_hash_table_insert(dumper_encaps,d,GINT_TO_POINTER(encap));
 299
 300     pushDumper(L,d);
 301     WSLUA_RETURN(1);
 302     /* The newly created Dumper object */
 303 }
 304
 305 WSLUA_METHOD Dumper_close(lua_State* L) {
 306     /* Closes a dumper. */
 307     Dumper* dp = (Dumper*)luaL_checkudata(L, 1, "Dumper");
 308     int err;
 309     char *err_info;
 310
 311     if (! *dp) {
 312         WSLUA_ERROR(Dumper_close,"Cannot operate on a closed dumper");
 313         return 0;
 314     }
 315
 316     g_hash_table_remove(dumper_encaps,*dp);
 317
 318     if (!wtap_dump_close(*dp, NULL, &err, &err_info)) {
 319         if (err_info != NULL) {
 320             luaL_error(L,"error closing: %s (%s)",
 321                        wtap_strerror(err), err_info);
 322             g_free(err_info);
 323         } else {
 324             luaL_error(L,"error closing: %s",
 325                        wtap_strerror(err));
 326         }
 327     }
 328
 329     /* this way if we close a dumper any attempt to use it (for everything but GC) will yield an error */
 330     *dp = NULL;
 331
 332     return 0;
 333 }
 334
 335 WSLUA_METHOD Dumper_flush(lua_State* L) {
 336     /*
 337      Writes all unsaved data of a dumper to the disk.
 338      */
 339     Dumper d = checkDumper(L,1);
 340     int err;
 341
 342     if (!d) return 0;
 343
 344     if (!wtap_dump_flush(d, &err)) {
 345         luaL_error(L,"error while dumping: %s",
 346                    wtap_strerror(err));
 347     }
 348
 349     return 0;
 350 }
 351
 352 WSLUA_METHOD Dumper_dump(lua_State* L) {
 353     /*
 354      Dumps an arbitrary packet.
 355      Note: Dumper:dump_current() will fit best in most cases.
 356      */
 357 #define WSLUA_ARG_Dumper_dump_TIMESTAMP 2 /* The absolute timestamp the packet will have. */
 358 #define WSLUA_ARG_Dumper_dump_PSEUDOHEADER 3 /* The `PseudoHeader` to use. */
 359 #define WSLUA_ARG_Dumper_dump_BYTEARRAY 4 /* The data to be saved */
 360
 361     Dumper d = checkDumper(L,1);
 362     PseudoHeader ph;
 363     ByteArray ba;
 364     wtap_rec rec;
 365     double ts;
 366     int err;
 367     char *err_info;
 368
 369     if (!d) return 0;
 370
 371     ts = luaL_checknumber(L,WSLUA_ARG_Dumper_dump_TIMESTAMP);
 372     ph = checkPseudoHeader(L,WSLUA_ARG_Dumper_dump_PSEUDOHEADER);
 373
 374     if (!ph) {
 375         WSLUA_ARG_ERROR(Dumper_dump,PSEUDOHEADER,"need a PseudoHeader");
 376         return 0;
 377     }
 378
 379     ba = checkByteArray(L,WSLUA_ARG_Dumper_dump_BYTEARRAY);
 380
 381     if (! ba) {
 382         WSLUA_ARG_ERROR(Dumper_dump,BYTEARRAY,"must be a ByteArray");
 383         return 0;
 384     }
 385
 386     memset(&rec, 0, sizeof rec);
 387
 388     rec.rec_type = REC_TYPE_PACKET;
 389
 390     rec.presence_flags = WTAP_HAS_TS;
 391     rec.ts.secs  = (unsigned int)(floor(ts));
 392     rec.ts.nsecs = (unsigned int)(floor((ts - (double)rec.ts.secs) * 1000000000));
 393
 394     rec.rec_header.packet_header.len       = ba->len;
 395     rec.rec_header.packet_header.caplen    = ba->len;
 396     rec.rec_header.packet_header.pkt_encap = DUMPER_ENCAP(d);
 397     if (ph->wph) {
 398         rec.rec_header.packet_header.pseudo_header = *ph->wph;
 399     }
 400
 401     /* TODO: Can we get access to pinfo->rec->block here somehow? We
 402      * should be copying it to pkthdr.pkt_block if we can. */
 403
 404     if (! wtap_dump(d, &rec, ba->data, &err, &err_info)) {
 405         switch (err) {
 406
 407         case WTAP_ERR_UNWRITABLE_REC_DATA:
 408             luaL_error(L,"error while dumping: %s (%s)",
 409                        wtap_strerror(err), err_info);
 410             g_free(err_info);
 411             break;
 412
 413         default:
 414             luaL_error(L,"error while dumping: %s",
 415                        wtap_strerror(err));
 416             break;
 417         }
 418     }
 419
 420     return 0;
 421
 422 }
 423
 424 WSLUA_METHOD Dumper_new_for_current(lua_State* L) {
 425     /*
 426      Creates a capture file using the same encapsulation as the one of the current packet.
 427      */
 428 #define WSLUA_OPTARG_Dumper_new_for_current_FILETYPE 2 /* The file type. Defaults to pcapng. */
 429     Dumper d;
 430     const char* fname = luaL_checkstring(L,1);
 431     int filetype = (int)luaL_optinteger(L,WSLUA_OPTARG_Dumper_new_for_current_FILETYPE,wtap_pcapng_file_type_subtype());
 432     int encap;
 433     int err = 0;
 434     char *err_info = NULL;
 435     const char* filename = cross_plat_fname(fname);
 436     wtap_dump_params params = WTAP_DUMP_PARAMS_INIT;
 437
 438     if (! lua_pinfo ) {
 439         WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector");
 440         return 0;
 441     }
 442
 443     if (lua_pinfo->rec->rec_type != REC_TYPE_PACKET) {
 444         return 0;
 445     }
 446
 447     encap = lua_pinfo->rec->rec_header.packet_header.pkt_encap;
 448     params.encap = encap;
 449     d = wtap_dump_open(filename, filetype, WTAP_UNCOMPRESSED, &params, &err,
 450                        &err_info);
 451
 452     if (! d ) {
 453         switch (err) {
 454         case WTAP_ERR_NOT_REGULAR_FILE:
 455             luaL_error(L,"The file \"%s\" is a \"special file\" or socket or other non-regular file",
 456                        filename);
 457             break;
 458
 459         case WTAP_ERR_CANT_WRITE_TO_PIPE:
 460             luaL_error(L,"The file \"%s\" is a pipe, and %s capture files can't be written to a pipe",
 461                        filename, wtap_file_type_subtype_description(filetype));
 462             break;
 463
 464         case WTAP_ERR_UNWRITABLE_FILE_TYPE:
 465             luaL_error(L,"Files of file type %s cannot be written",
 466                        wtap_file_type_subtype_description(filetype));
 467             break;
 468
 469         case WTAP_ERR_UNWRITABLE_ENCAP:
 470             luaL_error(L,"Files of file type %s don't support encapsulation %s",
 471                        wtap_file_type_subtype_description(filetype),
 472                        wtap_encap_name(encap));
 473             break;
 474
 475         case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
 476             luaL_error(L,"Files of file type %s don't support per-packet encapsulation",
 477                        wtap_file_type_subtype_description(filetype));
 478             break;
 479
 480         case WTAP_ERR_CANT_OPEN:
 481             luaL_error(L,"The file \"%s\" could not be created for some unknown reason",
 482                        filename);
 483             break;
 484
 485         case WTAP_ERR_SHORT_WRITE:
 486             luaL_error(L,"A full header couldn't be written to the file \"%s\".",
 487                        filename);
 488             break;
 489
 490         case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
 491             luaL_error(L,"Files of file type %s cannot be written as a compressed file",
 492                        wtap_file_type_subtype_description(filetype));
 493             break;
 494
 495         case WTAP_ERR_INTERNAL:
 496              luaL_error(L,"An internal error occurred creating the file \"%s\" (%s)",
 497                         filename,
 498                         err_info != NULL ? err_info : "no information supplied");
 499              g_free(err_info);
 500              break;
 501
 502         default:
 503             luaL_error(L,"error while opening \"%s\": %s",
 504                        filename,
 505                        wtap_strerror(err));
 506             break;
 507         }
 508         return 0;
 509     }
 510
 511     pushDumper(L,d);
 512     WSLUA_RETURN(1); /* The newly created Dumper Object */
 513
 514 }
 515
 516 WSLUA_METHOD Dumper_dump_current(lua_State* L) {
 517     /*
 518      Dumps the current packet as it is.
 519      */
 520     Dumper d = checkDumper(L,1);
 521     wtap_rec rec;
 522     const unsigned char* data;
 523     tvbuff_t* tvb;
 524     struct data_source *data_src;
 525     int err = 0;
 526     char *err_info;
 527
 528     if (!d) return 0;
 529
 530     if (! lua_pinfo ) {
 531         WSLUA_ERROR(Dumper_new_for_current,"Cannot be used outside a tap or a dissector");
 532         return 0;
 533     }
 534
 535     if (lua_pinfo->rec->rec_type != REC_TYPE_PACKET) {
 536         return 0;
 537     }
 538
 539     data_src = (struct data_source*) (lua_pinfo->data_src->data);
 540     if (!data_src)
 541         return 0;
 542
 543     tvb = get_data_source_tvb(data_src);
 544
 545     memset(&rec, 0, sizeof rec);
 546
 547     rec.rec_type                           = REC_TYPE_PACKET;
 548     rec.presence_flags                     = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
 549     rec.ts                                 = lua_pinfo->abs_ts;
 550     rec.rec_header.packet_header.len       = tvb_reported_length(tvb);
 551     rec.rec_header.packet_header.caplen    = tvb_captured_length(tvb);
 552     rec.rec_header.packet_header.pkt_encap = lua_pinfo->rec->rec_header.packet_header.pkt_encap;
 553     rec.rec_header.packet_header.pseudo_header = *lua_pinfo->pseudo_header;
 554
 555     /*
 556      * wtap_dump does not modify rec.block, so it should be possible to
 557      * pass epan_get_modified_block() or lua_pinfo->rec->block directly.
 558      * Temporarily duplicating the memory should not hurt though.
 559      */
 560     if (lua_pinfo->fd->has_modified_block) {
 561         rec.block = epan_get_modified_block(lua_pinfo->epan, lua_pinfo->fd);
 562         rec.block_was_modified = true;
 563     } else {
 564         rec.block = lua_pinfo->rec->block;
 565     }
 566
 567     data = (const unsigned char *)tvb_memdup(lua_pinfo->pool,tvb,0,rec.rec_header.packet_header.caplen);
 568
 569     if (! wtap_dump(d, &rec, data, &err, &err_info)) {
 570         switch (err) {
 571
 572         case WTAP_ERR_UNWRITABLE_REC_DATA:
 573             luaL_error(L,"error while dumping: %s (%s)",
 574                        wtap_strerror(err), err_info);
 575             g_free(err_info);
 576             break;
 577
 578         default:
 579             luaL_error(L,"error while dumping: %s",
 580                        wtap_strerror(err));
 581             break;
 582         }
 583     }
 584
 585     return 0;
 586 }
 587
 588 /* Gets registered as metamethod automatically by WSLUA_REGISTER_CLASS/META */
 589 static int Dumper__gc(lua_State* L) {
 590     Dumper* dp = (Dumper*)luaL_checkudata(L, 1, "Dumper");
 591     int err;
 592     char *err_info;
 593
 594     /* If we are Garbage Collected it means the Dumper is no longer usable. Close it */
 595
 596     if (! *dp)
 597         return 0; /* already closed, nothing to do! */
 598
 599     g_hash_table_remove(dumper_encaps,*dp);
 600
 601     if (!wtap_dump_close(*dp, NULL, &err, &err_info)) {
 602         if (err_info != NULL) {
 603             luaL_error(L,"error closing: %s (%s)",
 604                        wtap_strerror(err), err_info);
 605             g_free(err_info);
 606         } else {
 607             luaL_error(L,"error closing: %s",
 608                        wtap_strerror(err));
 609         }
 610     }
 611
 612     return 0;
 613 }
 614
 615
 616 WSLUA_METHODS Dumper_methods[] = {
 617     WSLUA_CLASS_FNREG(Dumper,new),
 618     WSLUA_CLASS_FNREG(Dumper,new_for_current),
 619     WSLUA_CLASS_FNREG(Dumper,close),
 620     WSLUA_CLASS_FNREG(Dumper,flush),
 621     WSLUA_CLASS_FNREG(Dumper,dump),
 622     WSLUA_CLASS_FNREG(Dumper,dump_current),
 623     { NULL, NULL }
 624 };
 625
 626 WSLUA_META Dumper_meta[] = {
 627     { NULL, NULL }
 628 };
 629
 630 int Dumper_register(lua_State* L) {
 631     if (dumper_encaps != NULL) {
 632         g_hash_table_unref(dumper_encaps);
 633     }
 634     dumper_encaps = g_hash_table_new(g_direct_hash,g_direct_equal);
 635     WSLUA_REGISTER_CLASS(Dumper);
 636     return 0;
 637 }
 638
 639 /*
 640  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 641  *
 642  * Local variables:
 643  * c-basic-offset: 4
 644  * tab-width: 8
 645  * indent-tabs-mode: nil
 646  * End:
 647  *
 648  * vi: set shiftwidth=4 tabstop=8 expandtab:
 649  * :indentSize=4:tabSize=8:noTabs=true:
 650  */