自学教程：C++ wtap_dump_file_write函数代码示例

static gboolean k12_dump_record(wtap_dumper *wdh, guint32 len,  guint8* buffer, int *err_p) {    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;    guint32 junky_offset = (0x2000 - ( (k12->file_offset - 0x200) % 0x2000 )) % 0x2000;    if (len > junky_offset) {        if (junky_offset) {            if (! wtap_dump_file_write(wdh, buffer, junky_offset, err_p))                return FALSE;        }        if (! wtap_dump_file_write(wdh, dumpy_junk, 0x10, err_p))            return FALSE;        if (! wtap_dump_file_write(wdh, buffer+junky_offset, len - junky_offset, err_p))            return FALSE;        k12->file_offset += len + 0x10;    } else {        if (! wtap_dump_file_write(wdh, buffer, len, err_p))            return FALSE;        k12->file_offset += len;    }    k12->num_of_records++;    return TRUE;}

static gboolean k12_dump_record(wtap_dumper *wdh, guint32 len,  guint8* buffer, int *err_p) {    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;    guint32 junky_offset = (8192 - ( (k12->file_offset - K12_FILE_HDR_LEN) % 8192 )) % 8192;    if (len > junky_offset) {        if (junky_offset) {            if (! wtap_dump_file_write(wdh, buffer, junky_offset, err_p))                return FALSE;        }        if (! wtap_dump_file_write(wdh, dumpy_junk, K12_FILE_BLOB_LEN, err_p))            return FALSE;        if (! wtap_dump_file_write(wdh, buffer+junky_offset, len - junky_offset, err_p))            return FALSE;        k12->file_offset += len + K12_FILE_BLOB_LEN;        k12->file_len += len + K12_FILE_BLOB_LEN;    } else {        if (! wtap_dump_file_write(wdh, buffer, len, err_p))            return FALSE;        k12->file_offset += len;        k12->file_len += len;    }    k12->num_of_records++;    return TRUE;}

static gboolean k12_dump_close(wtap_dumper *wdh, int *err) {    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;    union {        guint8 b[sizeof(guint32)];        guint32 u;    } d;    if (! wtap_dump_file_write(wdh, k12_eof, 2, err))        return FALSE;    if (wtap_dump_file_seek(wdh, 8, SEEK_SET, err) == -1)        return FALSE;    d.u = g_htonl(k12->file_len);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    d.u = g_htonl(k12->num_of_records);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    return TRUE;}

/* yeah this function is a little weird, but I'm mimicking Lua's actual code for io:write() */WSLUA_METHOD File_write(lua_State* L) {    /* Writes to the File, similar to Lua's file:write().  See Lua 5.x ref manual for file:write(). */    File f = checkFile(L,1);    int arg = 2;                   /* beginning index for arguments */    int nargs = lua_gettop(L) - 1;    int status = TRUE;    int err = 0;    if (!f->wdh) {        g_warning("Error in File read: this File object instance is for reading only");        return 0;    }    lua_pushvalue(L, 1);  /* push File at the stack top (to be returned) */    for (; nargs--; arg++) {        size_t len;        const char *s = luaL_checklstring(L, arg, &len);        status = wtap_dump_file_write(f->wdh, s, len, &err);        if (!status) break;        f->wdh->bytes_dumped += len;    }    if (!status) {        lua_pop(L,1); /* pop the extraneous File object */        lua_pushnil(L);        lua_pushfstring(L, "File write error: %s", g_strerror(err));        lua_pushinteger(L, err);        return 3;    }    return 1;  /* File object already on stack top */}

static gboolean k12_dump_close(wtap_dumper *wdh, int *err) {    k12_dump_t *k12 = (k12_dump_t *)wdh->priv;    union {        guint8 b[sizeof(guint32)];        guint32 u;    } d;    if (! wtap_dump_file_write(wdh, k12_eof, 2, err))        return FALSE;    k12->file_len += 2;    if (wtap_dump_file_seek(wdh, K12_FILE_HDR_FILE_SIZE, SEEK_SET, err) == -1)        return FALSE;    d.u = g_htonl(k12->file_len);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    if (wtap_dump_file_seek(wdh, K12_FILE_HDR_PAGE_SIZE, SEEK_SET, err) == -1)        return FALSE;    d.u = g_htonl(8192);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    if (wtap_dump_file_seek(wdh, K12_FILE_HDR_RECORD_COUNT_1, SEEK_SET, err) == -1)        return FALSE;    d.u = g_htonl(k12->num_of_records);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    if (wtap_dump_file_seek(wdh, K12_FILE_HDR_RECORD_COUNT_2, SEEK_SET, err) == -1)        return FALSE;    d.u = g_htonl(k12->num_of_records);    if (! wtap_dump_file_write(wdh, d.b, 4, err))        return FALSE;    return TRUE;}

/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on   failure */gboolean snoop_dump_open(wtap_dumper *wdh, int *err){	struct snoop_hdr file_hdr;	/* This is a snoop file */	wdh->subtype_write = snoop_dump;	/* Write the file header. */	if (!wtap_dump_file_write(wdh, &snoop_magic, sizeof snoop_magic, err))		return FALSE;	/* current "snoop" format is 2 */	file_hdr.version = g_htonl(2);	file_hdr.network = g_htonl(wtap_encap[wdh->encap]);	if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))		return FALSE;	return TRUE;}

gboolean eyesdn_dump_open(wtap_dumper *wdh, int *err){	wdh->subtype_write=eyesdn_dump;	if (!wtap_dump_file_write(wdh, eyesdn_hdr_magic,	    EYESDN_HDR_MAGIC_SIZE, err))		return FALSE;	wdh->bytes_dumped += EYESDN_HDR_MAGIC_SIZE;	*err=0;	return TRUE;}

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write "cnt" bytes of zero with error control *---------------------------------------------------*/static gboolean s0write(wtap_dumper *wdh, size_t cnt, int *err){      size_t snack;      while (cnt) {            snack = cnt > 64 ? 64 : cnt;            if (!wtap_dump_file_write(wdh, z64, snack, err))                  return FALSE;            cnt -= snack;      }      return TRUE; /* ok */}

gboolean k12_dump_open(wtap_dumper *wdh, int *err) {    k12_dump_t *k12;    if ( ! wtap_dump_file_write(wdh, k12_file_magic, 8, err)) {        return FALSE;    }    if (wtap_dump_file_seek(wdh, 0x200, SEEK_SET, err) == -1)        return FALSE;    wdh->subtype_write = k12_dump;    wdh->subtype_close = k12_dump_close;    k12 = (k12_dump_t *)g_malloc(sizeof(k12_dump_t));    wdh->priv = (void *)k12;    k12->file_len = 0x200;    k12->num_of_records = 0;    k12->file_offset  = 0x200;    return TRUE;}

/* Returns TRUE on success, FALSE on failure;   sets "*err" to an error code on failure */gboolean nettl_dump_open(wtap_dumper *wdh, int *err){    struct nettl_file_hdr file_hdr;    /* This is a nettl file */    wdh->subtype_write = nettl_dump;    /* Write the file header. */    memset(&file_hdr,0,sizeof(file_hdr));    memcpy(file_hdr.magic,nettl_magic_hpux10,sizeof(file_hdr.magic));    g_strlcpy(file_hdr.file_name,"/tmp/wireshark.TRC000",NETTL_FILENAME_SIZE);    g_strlcpy(file_hdr.tz,"UTC",20);    g_strlcpy(file_hdr.host_name,"",9);    g_strlcpy(file_hdr.os_vers,"B.11.11",9);    file_hdr.os_v=0x55;    g_strlcpy(file_hdr.model,"9000/800",11);    file_hdr.unknown=g_htons(0x406);    if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))        return FALSE;    wdh->bytes_dumped += sizeof(file_hdr);    return TRUE;}

/* Write a record for a packet to a dump file.   Returns TRUE on success, FALSE on failure. */static gboolean nettl_dump(wtap_dumper *wdh,	const struct wtap_pkthdr *phdr,	const guint8 *pd, int *err){	const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;	struct nettlrec_hdr rec_hdr;	guint8 dummyc[24];	/* We can only write packet records. */	if (phdr->rec_type != REC_TYPE_PACKET) {		*err = WTAP_ERR_REC_TYPE_UNSUPPORTED;		return FALSE;	}	/* Don't write anything we're not willing to read. */	if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {		*err = WTAP_ERR_PACKET_TOO_LARGE;		return FALSE;	}	memset(&rec_hdr,0,sizeof(rec_hdr));        /* HP-UX 11.X header should be 68 bytes */	rec_hdr.hdr_len = g_htons(sizeof(rec_hdr) + 4);	rec_hdr.kind = g_htonl(NETTL_HDR_PDUIN);	rec_hdr.sec = g_htonl(phdr->ts.secs);	rec_hdr.usec = g_htonl(phdr->ts.nsecs/1000);	rec_hdr.caplen = g_htonl(phdr->caplen);	rec_hdr.length = g_htonl(phdr->len);	rec_hdr.devid = -1;	rec_hdr.pid = -1;	rec_hdr.uid = -1;	switch (phdr->pkt_encap) {		case WTAP_ENCAP_NETTL_FDDI:			/* account for pad bytes */			rec_hdr.caplen = g_htonl(phdr->caplen + 3);			rec_hdr.length = g_htonl(phdr->len + 3);                        /* fall through and fill the rest of the fields */		case WTAP_ENCAP_NETTL_ETHERNET:		case WTAP_ENCAP_NETTL_TOKEN_RING:		case WTAP_ENCAP_NETTL_RAW_IP:		case WTAP_ENCAP_NETTL_RAW_ICMP:		case WTAP_ENCAP_NETTL_RAW_ICMPV6:		case WTAP_ENCAP_NETTL_RAW_TELNET:		case WTAP_ENCAP_NETTL_UNKNOWN:			rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);			rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);			rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);			rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);			rec_hdr.uid = g_htons(pseudo_header->nettl.uid);			break;		case WTAP_ENCAP_RAW_IP:			rec_hdr.subsys = g_htons(NETTL_SUBSYS_NS_LS_IP);			break;		case WTAP_ENCAP_ETHERNET:			rec_hdr.subsys = g_htons(NETTL_SUBSYS_BTLAN);			break;		case WTAP_ENCAP_FDDI_BITSWAPPED:			rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_FDDI);			/* account for pad bytes */			rec_hdr.caplen = g_htonl(phdr->caplen + 3);			rec_hdr.length = g_htonl(phdr->len + 3);			break;		case WTAP_ENCAP_TOKEN_RING:			rec_hdr.subsys = g_htons(NETTL_SUBSYS_PCI_TR);			break;#if 0		case WTAP_ENCAP_NETTL_X25:			rec_hdr.caplen = g_htonl(phdr->caplen + 24);			rec_hdr.length = g_htonl(phdr->len + 24);			rec_hdr.subsys = g_htons(pseudo_header->nettl.subsys);			rec_hdr.devid = g_htonl(pseudo_header->nettl.devid);			rec_hdr.kind = g_htonl(pseudo_header->nettl.kind);			rec_hdr.pid = g_htonl(pseudo_header->nettl.pid);			rec_hdr.uid = g_htons(pseudo_header->nettl.uid);			break;#endif		default:			/* found one we don't support */			*err = WTAP_ERR_UNSUPPORTED_ENCAP;			return FALSE;	}	if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof(rec_hdr), err))		return FALSE;	wdh->bytes_dumped += sizeof(rec_hdr);	/* Write out 4 extra bytes of unknown stuff for HP-UX11	 * header format.	 */	memset(dummyc, 0, sizeof dummyc);	if (!wtap_dump_file_write(wdh, dummyc, 4, err))		return FALSE;//.........这里部分代码省略.........

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write a 32-bit value as little-endian *---------------------------------------------------*/static gboolean s32write(wtap_dumper *wdh, const guint32 s32, int *err){      guint32 s32_le = GUINT32_TO_LE(s32);      return wtap_dump_file_write(wdh, &s32_le, 4, err);}

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write a 16-bit value as little-endian *---------------------------------------------------*/static gboolean s16write(wtap_dumper *wdh, const guint16 s16, int *err){      guint16 s16_le = GUINT16_TO_LE(s16);      return wtap_dump_file_write(wdh, &s16_le, 2, err);}

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write an 8-bit value *---------------------------------------------------*/static gboolean s8write(wtap_dumper *wdh, const guint8 s8, int *err){      return wtap_dump_file_write(wdh, &s8, 1, err);}

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write a 16-bit value with error control *---------------------------------------------------*/static gboolean s16write(wtap_dumper *wdh, const guint16 s16, int *err){	return wtap_dump_file_write(wdh, &s16, 2, err);}

/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on   failure */gboolean libpcap_dump_open(wtap_dumper *wdh, int *err){	guint32 magic;	struct pcap_hdr file_hdr;	/* This is a libpcap file */	wdh->subtype_write = libpcap_dump;	wdh->subtype_close = NULL;	/* Write the file header. */	switch (wdh->file_type_subtype) {	case WTAP_FILE_TYPE_SUBTYPE_PCAP:	case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417:	/* modified, but with the old magic, sigh */	case WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA:	/* Nokia libpcap of some sort */		magic = PCAP_MAGIC;		wdh->tsprecision = WTAP_TSPREC_USEC;		break;	case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915:	/* new magic, extra crap */	case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029:		magic = PCAP_MODIFIED_MAGIC;		wdh->tsprecision = WTAP_TSPREC_USEC;		break;	case WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC:		/* same as WTAP_FILE_TYPE_SUBTYPE_PCAP, but nsec precision */		magic = PCAP_NSEC_MAGIC;		wdh->tsprecision = WTAP_TSPREC_NSEC;		break;	default:		/* We should never get here - our open routine		   should only get called for the types above. */		*err = WTAP_ERR_UNWRITABLE_FILE_TYPE;		return FALSE;	}	if (!wtap_dump_file_write(wdh, &magic, sizeof magic, err))		return FALSE;	wdh->bytes_dumped += sizeof magic;	/* current "libpcap" format is 2.4 */	file_hdr.version_major = 2;	file_hdr.version_minor = 4;	file_hdr.thiszone = 0;	/* XXX - current offset? */	file_hdr.sigfigs = 0;	/* unknown, but also apparently unused */	/*	 * Tcpdump cannot handle capture files with a snapshot length of 0,	 * as BPF filters return either 0 if they fail or the snapshot length	 * if they succeed, and a snapshot length of 0 means success is	 * indistinguishable from failure and the filter expression would	 * reject all packets.	 *	 * A snapshot length of 0, inside Wiretap, means "snapshot length	 * unknown"; if the snapshot length supplied to us is 0, we make	 * the snapshot length in the header file WTAP_MAX_PACKET_SIZE.	 */	file_hdr.snaplen = (wdh->snaplen != 0) ? wdh->snaplen :						 WTAP_MAX_PACKET_SIZE;	file_hdr.network = wtap_wtap_encap_to_pcap_encap(wdh->encap);	if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))		return FALSE;	wdh->bytes_dumped += sizeof file_hdr;	return TRUE;}

/*--------------------------------------------------- * Returns TRUE on success, FALSE on error * Write a 32-bit value with error control *---------------------------------------------------*/static gboolean s32write(wtap_dumper *wdh, const guint32 s32, int *err){	return wtap_dump_file_write(wdh, &s32, 4, err);}

/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on   failure. */gboolean network_instruments_dump_open(wtap_dumper *wdh, int *err){    observer_dump_private_state * private_state = NULL;    capture_file_header file_header;    tlv_header comment_header;    tlv_time_info time_header;    char comment[64];    size_t comment_length;    struct tm * current_time;    time_t system_time;    /* initialize the private state */    private_state = (observer_dump_private_state *) g_malloc(sizeof(observer_dump_private_state));    private_state->packet_count = 0;    private_state->network_type = wtap_to_observer_encap(wdh->encap);    private_state->time_format = TIME_INFO_GMT;    /* populate the fields of wdh */    wdh->priv = (void *) private_state;    wdh->subtype_write = observer_dump;    /* initialize the file header */    memset(&file_header, 0x00, sizeof(file_header));    g_strlcpy(file_header.observer_version, network_instruments_magic, 31);    file_header.offset_to_first_packet = (guint16)sizeof(file_header);    file_header.offset_to_first_packet_high_byte = 0;    /* create the file comment TLV */    {        time(&system_time);        current_time = localtime(&system_time);        memset(&comment, 0x00, sizeof(comment));        g_snprintf(comment, 64, "This capture was saved from Wireshark on %s", asctime(current_time));        comment_length = strlen(comment);        comment_header.type = INFORMATION_TYPE_COMMENT;        comment_header.length = (guint16) (sizeof(comment_header) + comment_length);        /* update the file header to account for the comment TLV */        file_header.number_of_information_elements++;        file_header.offset_to_first_packet += comment_header.length;    }    /* create the timestamp encoding TLV */    {        time_header.type = INFORMATION_TYPE_TIME_INFO;        time_header.length = (guint16) (sizeof(time_header));        time_header.time_format = TIME_INFO_GMT;        /* update the file header to account for the timestamp encoding TLV */        file_header.number_of_information_elements++;        file_header.offset_to_first_packet += time_header.length;    }    /* write the file header, swapping any multibyte fields first */    CAPTURE_FILE_HEADER_TO_LE_IN_PLACE(file_header);    if (!wtap_dump_file_write(wdh, &file_header, sizeof(file_header), err)) {        return FALSE;    }    wdh->bytes_dumped += sizeof(file_header);    /* write the comment TLV */    {        TLV_HEADER_TO_LE_IN_PLACE(comment_header);        if (!wtap_dump_file_write(wdh, &comment_header, sizeof(comment_header), err)) {            return FALSE;        }        wdh->bytes_dumped += sizeof(comment_header);        if (!wtap_dump_file_write(wdh, &comment, comment_length, err)) {            return FALSE;        }        wdh->bytes_dumped += comment_length;    }    /* write the time info TLV */    {        TLV_TIME_INFO_TO_LE_IN_PLACE(time_header);        if (!wtap_dump_file_write(wdh, &time_header, sizeof(time_header), err)) {            return FALSE;        }        wdh->bytes_dumped += sizeof(time_header);    }    init_gmt_to_localtime_offset();    return TRUE;}

/*--------------------------------------------------- * Write a record for a packet to a dump file. * Returns TRUE on success, FALSE on failure. *---------------------------------------------------*/static gboolean lanalyzer_dump(wtap_dumper *wdh,	const struct wtap_pkthdr *phdr,	const guint8 *pd, int *err){      double x;      int    i;      int    len;	  struct timeval tv;      LA_TmpInfo *itmp = (LA_TmpInfo*)(wdh->priv);      struct timeval td;      int    thisSize = phdr->caplen + LA_PacketRecordSize + LA_RecordHeaderSize;      if (wdh->bytes_dumped + thisSize > LA_ProFileLimit) {            /* printf(" LA_ProFileLimit reached/n");     */            *err = EFBIG;            return FALSE; /* and don't forget the header */            }      len = phdr->caplen + (phdr->caplen ? LA_PacketRecordSize : 0);      if (!s16write(wdh, GUINT16_TO_LE(0x1005), err))            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(len), err))            return FALSE;      tv.tv_sec  = (long int) phdr->ts.secs;      tv.tv_usec = phdr->ts.nsecs / 1000;      if (!itmp->init) {            /* collect some information for the             * finally written header             */		    /* XXX - this conversion could probably improved, if the start uses ns */            itmp->start   = tv;            itmp->pkts    = 0;            itmp->init    = TRUE;            itmp->encap   = wdh->encap;            itmp->lastlen = 0;            }      my_timersub(&(tv),&(itmp->start),&td);      x   = (double) td.tv_usec;      x  += (double) td.tv_sec * 1000000;      x  *= 2;      if (!s16write(wdh, GUINT16_TO_LE(0x0001), err))             /* pr.rx_channels */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(0x0008), err))             /* pr.rx_errors   */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(phdr->len + 4), err))      /* pr.rx_frm_len  */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(phdr->caplen), err))       /* pr.rx_frm_sln  */            return FALSE;      for (i = 0; i < 3; i++) {            if (!s16write(wdh, GUINT16_TO_LE((guint16) x), err))  /* pr.rx_time[i]  */                  return FALSE;            x /= 0xffff;      }      if (!s32write(wdh, GUINT32_TO_LE(++itmp->pkts), err))       /* pr.pktno      */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(itmp->lastlen), err))      /* pr.prlen      */            return FALSE;      itmp->lastlen = len;      if (!s0write(wdh, 12, err))            return FALSE;      if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))            return FALSE;      wdh->bytes_dumped += thisSize;      return TRUE;}

/*--------------------------------------------------- * *---------------------------------------------------*/static gboolean lanalyzer_dump_header(wtap_dumper *wdh, int *err){      LA_TmpInfo *itmp   = (LA_TmpInfo*)(wdh->priv);      guint16 board_type = itmp->encap == WTAP_ENCAP_TOKEN_RING                              ? BOARD_325TR     /* LANalyzer Board Type */                              : BOARD_325;      /* LANalyzer Board Type */      time_t secs;      struct tm *fT;      /* The secs variable is needed to work around 32/64-bit time_t issues.         itmp->start is a timeval struct, which declares its tv_sec field         (itmp->start.tv_sec) as a long (typically 32 bits). time_t can be 32         or 64 bits, depending on the platform. Invoking as follows could         pass a pointer to a 32-bit long where a pointer to a 64-bit time_t         is expected: localtime((time_t*) &(itmp->start.tv_sec)) */      secs = itmp->start.tv_sec;      fT = localtime(&secs);      if (fT == NULL)            return FALSE;      if (wtap_dump_file_seek(wdh, 0, SEEK_SET, err) == -1)	    return FALSE;      if (!wtap_dump_file_write(wdh, &LA_HeaderRegularFake,                                sizeof LA_HeaderRegularFake, err))		return FALSE;      if (!wtap_dump_file_write(wdh, &LA_RxChannelNameFake,                                sizeof LA_RxChannelNameFake, err))		return FALSE;      if (!wtap_dump_file_write(wdh, &LA_TxChannelNameFake,                                sizeof LA_TxChannelNameFake, err))		return FALSE;      if (!wtap_dump_file_write(wdh, &LA_RxTemplateNameFake,                                sizeof LA_RxTemplateNameFake, err))		return FALSE;      if (!wtap_dump_file_write(wdh, &LA_TxTemplateNameFake,                                sizeof LA_TxTemplateNameFake, err))		return FALSE;      if (!wtap_dump_file_write(wdh, &LA_DisplayOptionsFake,                                sizeof LA_DisplayOptionsFake, err))		return FALSE;      /*-----------------------------------------------------------------*/      if (!s16write(wdh, GUINT16_TO_LE(RT_Summary), err))         /* rid */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(SummarySize), err))        /* rlen */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_mday, err))        /* s.datcre.day */            return FALSE;      if (!s8write(wdh, (guint8) (fT->tm_mon+1), err))     /* s.datcre.mon */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(fT->tm_year + 1900), err)) /* s.datcre.year */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_mday, err))        /* s.datclo.day */            return FALSE;      if (!s8write(wdh, (guint8) (fT->tm_mon+1), err))     /* s.datclo.mon */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(fT->tm_year + 1900), err)) /* s.datclo.year */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_sec, err))         /* s.timeopn.second */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_min, err))         /* s.timeopn.minute */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_hour, err))        /* s.timeopn.hour */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_mday, err))        /* s.timeopn.mday */            return FALSE;      if (!s0write(wdh, 2, err))            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_sec, err))         /* s.timeclo.second */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_min, err))         /* s.timeclo.minute */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_hour, err))        /* s.timeclo.hour */            return FALSE;      if (!s8write(wdh, (guint8) fT->tm_mday, err))        /* s.timeclo.mday */            return FALSE;      if (!s0write(wdh, 2, err))            return FALSE;      if (!s0write(wdh, 6, err))                           /* EAddr  == 0      */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(1), err))                  /* s.mxseqno */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(0), err))                  /* s.slcoffo */            return FALSE;      if (!s16write(wdh, GUINT16_TO_LE(1514), err))               /* s.mxslc */            return FALSE;      if (!s32write(wdh, GUINT32_TO_LE(itmp->pkts), err))         /* s.totpktt */            return FALSE;      /*       * statrg == 0; ? -1       * stptrg == 0; ? -1       * s.mxpkta[0]=0       */      if (!s0write(wdh, 12, err))            return FALSE;      if (!s32write(wdh, GUINT32_TO_LE(itmp->pkts), err))         /* sr.s.mxpkta[1]  */            return FALSE;//.........这里部分代码省略.........

/* Write a record for a packet to a dump file.   Returns TRUE on success, FALSE on failure. */static gboolean snoop_dump(wtap_dumper *wdh,	const struct wtap_pkthdr *phdr,	const guint8 *pd, int *err){	const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;	struct snooprec_hdr rec_hdr;	int reclen;	guint padlen;	static const char zeroes[4] = {0};	struct snoop_atm_hdr atm_hdr;	int atm_hdrsize;	if (wdh->encap == WTAP_ENCAP_ATM_PDUS)		atm_hdrsize = sizeof (struct snoop_atm_hdr);	else		atm_hdrsize = 0;	/* Record length = header length plus data length... */	reclen = (int)sizeof rec_hdr + phdr->caplen + atm_hdrsize;	/* ... plus enough bytes to pad it to a 4-byte boundary. */	padlen = ((reclen + 3) & ~3) - reclen;	reclen += padlen;	rec_hdr.orig_len = g_htonl(phdr->len + atm_hdrsize);	rec_hdr.incl_len = g_htonl(phdr->caplen + atm_hdrsize);	rec_hdr.rec_len = g_htonl(reclen);	rec_hdr.cum_drops = 0;	rec_hdr.ts_sec = g_htonl(phdr->ts.secs);	rec_hdr.ts_usec = g_htonl(phdr->ts.nsecs / 1000);	if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof rec_hdr, err))		return FALSE;	if (wdh->encap == WTAP_ENCAP_ATM_PDUS) {		/*		 * Write the ATM header.		 */		atm_hdr.flags =		    (pseudo_header->atm.channel == 0) ? 0x80 : 0x00;		switch (pseudo_header->atm.aal) {		case AAL_SIGNALLING:			/* Signalling AAL */			atm_hdr.flags |= 0x06;			break;		case AAL_5:			switch (pseudo_header->atm.type) {			case TRAF_LANE:				/* LANE */				atm_hdr.flags |= 0x01;				break;			case TRAF_LLCMX:				/* RFC 1483 LLC multiplexed traffic */				atm_hdr.flags |= 0x02;				break;			case TRAF_ILMI:				/* ILMI */				atm_hdr.flags |= 0x05;				break;			}			break;		}		atm_hdr.vpi = (guint8) pseudo_header->atm.vpi;		atm_hdr.vci = g_htons(pseudo_header->atm.vci);		if (!wtap_dump_file_write(wdh, &atm_hdr, sizeof atm_hdr, err))			return FALSE;	}	if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))		return FALSE;	/* Now write the padding. */	if (!wtap_dump_file_write(wdh, zeroes, padlen, err))		return FALSE;	return TRUE;}