#include "isprint.h"
#include <glib.h>
-#include <wsutil/pint.h>
#include <epan/packet.h>
#include <epan/exceptions.h>
#include <epan/etypes.h>
conversation_t *conversation;
guint32 if_port;
- if_port = htolel(INTERFACE_PORT | interface_num);
+ if_port = GUINT32_TO_LE(INTERFACE_PORT | interface_num);
if (pinfo->srcport == NO_ENDPOINT) {
conversation = get_usb_conversation(pinfo, &pinfo->src, &pinfo->dst, pinfo->srcport, if_port);
* but the new endpoint.
*/
usb_addr.device = ((const usb_address_t *)(pinfo->src.data))->device;
- usb_addr.endpoint = htolel(endpoint);
+ usb_addr.endpoint = GUINT32_TO_LE(endpoint);
SET_ADDRESS(&tmp_addr, AT_USB, USB_ADDR_LEN, (char *)&usb_addr);
conversation = get_usb_conversation(pinfo, &tmp_addr, &pinfo->dst, usb_addr.endpoint, pinfo->destport);
} else {
* but the new endpoint.
*/
usb_addr.device = ((const usb_address_t *)(pinfo->dst.data))->device;
- usb_addr.endpoint = htolel(endpoint);
+ usb_addr.endpoint = GUINT32_TO_LE(endpoint);
SET_ADDRESS(&tmp_addr, AT_USB, USB_ADDR_LEN, (char *)&usb_addr);
conversation = get_usb_conversation(pinfo, &pinfo->src, &tmp_addr, pinfo->srcport, usb_addr.endpoint);
}
if (is_request) {
src_addr.device = 0xffffffff;
src_addr.endpoint = src_endpoint = NO_ENDPOINT;
- dst_addr.device = htolel(tmp_addr);
- dst_addr.endpoint = dst_endpoint = htolel(endpoint);
+ dst_addr.device = GUINT32_TO_LE(tmp_addr);
+ dst_addr.endpoint = dst_endpoint = GUINT32_TO_LE(endpoint);
} else {
- src_addr.device = htolel(tmp_addr);
- src_addr.endpoint = src_endpoint = htolel(endpoint);
+ src_addr.device = GUINT32_TO_LE(tmp_addr);
+ src_addr.endpoint = src_endpoint = GUINT32_TO_LE(endpoint);
dst_addr.device = 0xffffffff;
dst_addr.endpoint = dst_endpoint = NO_ENDPOINT;
}
static address endpoint_addr;
endpoint = usb_trans_info->setup.wIndex & 0x0f;
- dst_addr.endpoint = dst_endpoint = htolel(endpoint);
+ dst_addr.endpoint = dst_endpoint = GUINT32_TO_LE(endpoint);
SET_ADDRESS(&endpoint_addr, AT_USB, USB_ADDR_LEN, (char *)&dst_addr);
conversation = get_usb_conversation(pinfo, &pinfo->src, &endpoint_addr, pinfo->srcport, dst_endpoint);
static address endpoint_addr;
endpoint = usb_trans_info->setup.wIndex & 0x0f;
- src_addr.endpoint = src_endpoint = htolel(endpoint);
+ src_addr.endpoint = src_endpoint = GUINT32_TO_LE(endpoint);
SET_ADDRESS(&endpoint_addr, AT_USB, USB_ADDR_LEN, (char *)&src_addr);
conversation = get_usb_conversation(pinfo, &endpoint_addr, &pinfo->dst, src_endpoint, pinfo->destport);
/* Frame Header */
/* constant fields */
- HeaderFrame.Key = htolel(CST_5VW_RECORDS_HEADER_KEY);
- HeaderFrame.HeaderSize = htoles(sizeof(t_5VW_TimeStamped_Header));
- HeaderFrame.HeaderType = htoles(CST_5VW_TIMESTAMPED_HEADER_TYPE);
- HeaderFrame.RecType = htolel(CST_5VW_CAPTURES_RECORD | CST_5VW_SYSTEM_RECORD);
- HeaderFrame.RecSubType = htolel(CST_5VW_FRAME_RECORD);
- HeaderFrame.RecNb = htolel(1);
+ HeaderFrame.Key = GUINT32_TO_LE(CST_5VW_RECORDS_HEADER_KEY);
+ HeaderFrame.HeaderSize = GUINT16_TO_LE(sizeof(t_5VW_TimeStamped_Header));
+ HeaderFrame.HeaderType = GUINT16_TO_LE(CST_5VW_TIMESTAMPED_HEADER_TYPE);
+ HeaderFrame.RecType = GUINT32_TO_LE(CST_5VW_CAPTURES_RECORD | CST_5VW_SYSTEM_RECORD);
+ HeaderFrame.RecSubType = GUINT32_TO_LE(CST_5VW_FRAME_RECORD);
+ HeaderFrame.RecNb = GUINT32_TO_LE(1);
/* record-dependent fields */
- HeaderFrame.Utc = htolel(phdr->ts.secs);
- HeaderFrame.NanoSecondes = htolel(phdr->ts.nsecs);
- HeaderFrame.RecSize = htolel(phdr->len);
- HeaderFrame.RecInfo = htolel(0);
+ HeaderFrame.Utc = GUINT32_TO_LE(phdr->ts.secs);
+ HeaderFrame.NanoSecondes = GUINT32_TO_LE(phdr->ts.nsecs);
+ HeaderFrame.RecSize = GUINT32_TO_LE(phdr->len);
+ HeaderFrame.RecInfo = GUINT32_TO_LE(0);
/* write the record header */
if (!wtap_dump_file_write(wdh, &HeaderFrame,
return FALSE;
/* fill in the Info_Header */
- file_hdr.Info_Header.Signature = htolel(CST_5VW_INFO_HEADER_KEY);
- file_hdr.Info_Header.Size = htolel(sizeof(t_5VW_Info_Header)); /* Total size of Header in bytes (included Signature) */
- file_hdr.Info_Header.Version = htolel(CST_5VW_INFO_RECORD_VERSION); /* Identify version and so the format of this record */
- file_hdr.Info_Header.DataSize = htolel(sizeof(t_5VW_Attributes_Header)
+ file_hdr.Info_Header.Signature = GUINT32_TO_LE(CST_5VW_INFO_HEADER_KEY);
+ file_hdr.Info_Header.Size = GUINT32_TO_LE(sizeof(t_5VW_Info_Header)); /* Total size of Header in bytes (included Signature) */
+ file_hdr.Info_Header.Version = GUINT32_TO_LE(CST_5VW_INFO_RECORD_VERSION); /* Identify version and so the format of this record */
+ file_hdr.Info_Header.DataSize = GUINT32_TO_LE(sizeof(t_5VW_Attributes_Header)
+ sizeof(guint32)
+ sizeof(t_5VW_Attributes_Header)
+ sizeof(guint32));
/* Total size of data included in the Info Record (except the header size) */
- file_hdr.Info_Header.FileType = htolel(wtap_encap[wdh->encap]); /* Type of the file */
+ file_hdr.Info_Header.FileType = GUINT32_TO_LE(wtap_encap[wdh->encap]); /* Type of the file */
file_hdr.Info_Header.Reserved[0] = 0; /* Reserved for future use */
file_hdr.Info_Header.Reserved[1] = 0; /* Reserved for future use */
file_hdr.Info_Header.Reserved[2] = 0; /* Reserved for future use */
/* fill in the HeaderDateCreation */
- file_hdr.HeaderDateCreation.Type = htolel(CST_5VW_IA_DATE_CREATION); /* Id of the attribute */
- file_hdr.HeaderDateCreation.Size = htoles(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
- file_hdr.HeaderDateCreation.Nb = htoles(1); /* Number of elements */
+ file_hdr.HeaderDateCreation.Type = GUINT32_TO_LE(CST_5VW_IA_DATE_CREATION); /* Id of the attribute */
+ file_hdr.HeaderDateCreation.Size = GUINT16_TO_LE(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
+ file_hdr.HeaderDateCreation.Nb = GUINT16_TO_LE(1); /* Number of elements */
/* fill in the Time field */
#ifdef _WIN32
_tzset();
#endif
- file_hdr.Time = htolel(time(NULL));
+ file_hdr.Time = GUINT32_TO_LE(time(NULL));
/* fill in the Time field */
- file_hdr.HeaderNbFrames.Type = htolel(CST_5VW_IA_CAP_INF_NB_TRAMES_STOCKEES); /* Id of the attribute */
- file_hdr.HeaderNbFrames.Size = htoles(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
- file_hdr.HeaderNbFrames.Nb = htoles(1); /* Number of elements */
+ file_hdr.HeaderNbFrames.Type = GUINT32_TO_LE(CST_5VW_IA_CAP_INF_NB_TRAMES_STOCKEES); /* Id of the attribute */
+ file_hdr.HeaderNbFrames.Size = GUINT16_TO_LE(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
+ file_hdr.HeaderNbFrames.Nb = GUINT16_TO_LE(1); /* Number of elements */
/* fill in the number of frames saved */
- file_hdr.TramesStockeesInFile = htolel(_5views->nframes);
+ file_hdr.TramesStockeesInFile = GUINT32_TO_LE(_5views->nframes);
/* Write the file header. */
if (!wtap_dump_file_write(wdh, &file_hdr, sizeof(t_5VW_Capture_Header),
len = phdr->caplen + (phdr->caplen ? LA_PacketRecordSize : 0);
- if (!s16write(wdh, htoles(0x1005), err))
+ if (!s16write(wdh, GUINT16_TO_LE(0x1005), err))
return FALSE;
- if (!s16write(wdh, htoles(len), err))
+ if (!s16write(wdh, GUINT16_TO_LE(len), err))
return FALSE;
tv.tv_sec = (long int) phdr->ts.secs;
x += (double) td.tv_sec * 1000000;
x *= 2;
- if (!s16write(wdh, htoles(0x0001), err)) /* pr.rx_channels */
+ if (!s16write(wdh, GUINT16_TO_LE(0x0001), err)) /* pr.rx_channels */
return FALSE;
- if (!s16write(wdh, htoles(0x0008), err)) /* pr.rx_errors */
+ if (!s16write(wdh, GUINT16_TO_LE(0x0008), err)) /* pr.rx_errors */
return FALSE;
- if (!s16write(wdh, htoles(phdr->len + 4), err)) /* pr.rx_frm_len */
+ if (!s16write(wdh, GUINT16_TO_LE(phdr->len + 4), err)) /* pr.rx_frm_len */
return FALSE;
- if (!s16write(wdh, htoles(phdr->caplen), err)) /* pr.rx_frm_sln */
+ if (!s16write(wdh, GUINT16_TO_LE(phdr->caplen), err)) /* pr.rx_frm_sln */
return FALSE;
for (i = 0; i < 3; i++) {
- if (!s16write(wdh, htoles((guint16) x), err)) /* pr.rx_time[i] */
+ if (!s16write(wdh, GUINT16_TO_LE((guint16) x), err)) /* pr.rx_time[i] */
return FALSE;
x /= 0xffff;
}
- if (!s32write(wdh, htolel(++itmp->pkts), err)) /* pr.pktno */
+ if (!s32write(wdh, GUINT32_TO_LE(++itmp->pkts), err)) /* pr.pktno */
return FALSE;
- if (!s16write(wdh, htoles(itmp->lastlen), err)) /* pr.prlen */
+ if (!s16write(wdh, GUINT16_TO_LE(itmp->lastlen), err)) /* pr.prlen */
return FALSE;
itmp->lastlen = len;
sizeof LA_DisplayOptionsFake, err))
return FALSE;
/*-----------------------------------------------------------------*/
- if (!s16write(wdh, htoles(RT_Summary), err)) /* rid */
+ if (!s16write(wdh, GUINT16_TO_LE(RT_Summary), err)) /* rid */
return FALSE;
- if (!s16write(wdh, htoles(SummarySize), err)) /* rlen */
+ 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, htoles(fT->tm_year + 1900), err)) /* s.datcre.year */
+ 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, htoles(fT->tm_year + 1900), err)) /* s.datclo.year */
+ 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;
return FALSE;
if (!s0write(wdh, 6, err)) /* EAddr == 0 */
return FALSE;
- if (!s16write(wdh, htoles(1), err)) /* s.mxseqno */
+ if (!s16write(wdh, GUINT16_TO_LE(1), err)) /* s.mxseqno */
return FALSE;
- if (!s16write(wdh, htoles(0), err)) /* s.slcoffo */
+ if (!s16write(wdh, GUINT16_TO_LE(0), err)) /* s.slcoffo */
return FALSE;
- if (!s16write(wdh, htoles(1514), err)) /* s.mxslc */
+ if (!s16write(wdh, GUINT16_TO_LE(1514), err)) /* s.mxslc */
return FALSE;
- if (!s32write(wdh, htolel(itmp->pkts), err)) /* s.totpktt */
+ if (!s32write(wdh, GUINT32_TO_LE(itmp->pkts), err)) /* s.totpktt */
return FALSE;
/*
* statrg == 0; ? -1
*/
if (!s0write(wdh, 12, err))
return FALSE;
- if (!s32write(wdh, htolel(itmp->pkts), err)) /* sr.s.mxpkta[1] */
+ if (!s32write(wdh, GUINT32_TO_LE(itmp->pkts), err)) /* sr.s.mxpkta[1] */
return FALSE;
if (!s0write(wdh, 34*4, err)) /* s.mxpkta[2-33]=0 */
return FALSE;
- if (!s16write(wdh, htoles(board_type), err))
+ if (!s16write(wdh, GUINT16_TO_LE(board_type), err))
return FALSE;
if (!s0write(wdh, 20, err)) /* board_version == 0 */
return FALSE;
/*-----------------------------------------------------------------*/
- if (!s16write(wdh, htoles(RT_SubfileSummary), err)) /* ssr.rid */
+ if (!s16write(wdh, GUINT16_TO_LE(RT_SubfileSummary), err)) /* ssr.rid */
return FALSE;
- if (!s16write(wdh, htoles(LA_SubfileSummaryRecordSize-4), err)) /* ssr.rlen */
+ if (!s16write(wdh, GUINT16_TO_LE(LA_SubfileSummaryRecordSize-4), err)) /* ssr.rlen */
return FALSE;
- if (!s16write(wdh, htoles(1), err)) /* ssr.seqno */
+ if (!s16write(wdh, GUINT16_TO_LE(1), err)) /* ssr.seqno */
return FALSE;
- if (!s32write(wdh, htolel(itmp->pkts), err)) /* ssr.totpkts */
+ if (!s32write(wdh, GUINT32_TO_LE(itmp->pkts), err)) /* ssr.totpkts */
return FALSE;
/*-----------------------------------------------------------------*/
if (!wtap_dump_file_write(wdh, &LA_CyclicInformationFake,
sizeof LA_CyclicInformationFake, err))
return FALSE;
/*-----------------------------------------------------------------*/
- if (!s16write(wdh, htoles(RT_Index), err)) /* rid */
+ if (!s16write(wdh, GUINT16_TO_LE(RT_Index), err)) /* rid */
return FALSE;
- if (!s16write(wdh, htoles(LA_IndexRecordSize -4), err)) /* rlen */
+ if (!s16write(wdh, GUINT16_TO_LE(LA_IndexRecordSize -4), err)) /* rlen */
return FALSE;
- if (!s16write(wdh, htoles(LA_IndexSize), err)) /* idxsp */
+ if (!s16write(wdh, GUINT16_TO_LE(LA_IndexSize), err)) /* idxsp */
return FALSE;
if (!s0write(wdh, LA_IndexRecordSize - 6, err))
return FALSE;
switch (wdh->file_type_subtype) {
case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
- rec_1_x_hdr.ts_delta = htolel(secs*1000 + (nsecs + 500000)/1000000);
- rec_1_x_hdr.orig_len = htoles(phdr->len + atm_hdrsize);
- rec_1_x_hdr.incl_len = htoles(phdr->caplen + atm_hdrsize);
+ rec_1_x_hdr.ts_delta = GUINT32_TO_LE(secs*1000 + (nsecs + 500000)/1000000);
+ rec_1_x_hdr.orig_len = GUINT16_TO_LE(phdr->len + atm_hdrsize);
+ rec_1_x_hdr.incl_len = GUINT16_TO_LE(phdr->caplen + atm_hdrsize);
hdrp = &rec_1_x_hdr;
hdr_size = sizeof rec_1_x_hdr;
break;
case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
- rec_2_x_hdr.ts_delta = htolell(secs*1000000 + (nsecs + 500)/1000);
- rec_2_x_hdr.orig_len = htolel(phdr->len + atm_hdrsize);
- rec_2_x_hdr.incl_len = htolel(phdr->caplen + atm_hdrsize);
+ rec_2_x_hdr.ts_delta = GUINT64_TO_LE(secs*1000000 + (nsecs + 500)/1000);
+ rec_2_x_hdr.orig_len = GUINT32_TO_LE(phdr->len + atm_hdrsize);
+ rec_2_x_hdr.incl_len = GUINT32_TO_LE(phdr->caplen + atm_hdrsize);
hdrp = &rec_2_x_hdr;
hdr_size = sizeof rec_2_x_hdr;
break;
}
netmon->frame_table[netmon->frame_table_index] =
- htolel(netmon->frame_table_offset);
+ GUINT32_TO_LE(netmon->frame_table_offset);
/*
* Is this the last record we can write?
* type in the file header is irrelevant. Set it
* to 1, just as Network Monitor does.
*/
- file_hdr.network = htoles(1);
+ file_hdr.network = GUINT16_TO_LE(1);
} else
- file_hdr.network = htoles(wtap_encap[wdh->encap]);
+ file_hdr.network = GUINT16_TO_LE(wtap_encap[wdh->encap]);
tm = localtime(&netmon->first_record_time.secs);
if (tm != NULL) {
- file_hdr.ts_year = htoles(1900 + tm->tm_year);
- file_hdr.ts_month = htoles(tm->tm_mon + 1);
- file_hdr.ts_dow = htoles(tm->tm_wday);
- file_hdr.ts_day = htoles(tm->tm_mday);
- file_hdr.ts_hour = htoles(tm->tm_hour);
- file_hdr.ts_min = htoles(tm->tm_min);
- file_hdr.ts_sec = htoles(tm->tm_sec);
+ file_hdr.ts_year = GUINT16_TO_LE(1900 + tm->tm_year);
+ file_hdr.ts_month = GUINT16_TO_LE(tm->tm_mon + 1);
+ file_hdr.ts_dow = GUINT16_TO_LE(tm->tm_wday);
+ file_hdr.ts_day = GUINT16_TO_LE(tm->tm_mday);
+ file_hdr.ts_hour = GUINT16_TO_LE(tm->tm_hour);
+ file_hdr.ts_min = GUINT16_TO_LE(tm->tm_min);
+ file_hdr.ts_sec = GUINT16_TO_LE(tm->tm_sec);
} else {
- file_hdr.ts_year = htoles(1900 + 0);
- file_hdr.ts_month = htoles(0 + 1);
- file_hdr.ts_dow = htoles(0);
- file_hdr.ts_day = htoles(0);
- file_hdr.ts_hour = htoles(0);
- file_hdr.ts_min = htoles(0);
- file_hdr.ts_sec = htoles(0);
+ file_hdr.ts_year = GUINT16_TO_LE(1900 + 0);
+ file_hdr.ts_month = GUINT16_TO_LE(0 + 1);
+ file_hdr.ts_dow = GUINT16_TO_LE(0);
+ file_hdr.ts_day = GUINT16_TO_LE(0);
+ file_hdr.ts_hour = GUINT16_TO_LE(0);
+ file_hdr.ts_min = GUINT16_TO_LE(0);
+ file_hdr.ts_sec = GUINT16_TO_LE(0);
}
- file_hdr.ts_msec = htoles(netmon->first_record_time.nsecs/1000000);
- file_hdr.frametableoffset = htolel(netmon->frame_table_offset);
+ file_hdr.ts_msec = GUINT16_TO_LE(netmon->first_record_time.nsecs/1000000);
+ file_hdr.frametableoffset = GUINT32_TO_LE(netmon->frame_table_offset);
file_hdr.frametablelength =
- htolel(netmon->frame_table_index * sizeof *netmon->frame_table);
+ GUINT32_TO_LE(netmon->frame_table_index * sizeof *netmon->frame_table);
if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))
return FALSE;
nspr_signature_v10_t sig10;
/* populate the record */
- val16b = htoles(NSPR_SIGNATURE_V10);
+ val16b = GUINT16_TO_LE(NSPR_SIGNATURE_V10);
memcpy(sig10.phd.ph_RecordType, &val16b, sizeof sig10.phd.ph_RecordType);
- val16b = htoles(nspr_signature_v10_s);
+ val16b = GUINT16_TO_LE(nspr_signature_v10_s);
memcpy(sig10.phd.ph_RecordSize, &val16b, sizeof sig10.phd.ph_RecordSize);
memset(sig10.sig_Signature, 0, NSPR_SIGSIZE_V10);
g_strlcpy(sig10.sig_Signature, NSPR_SIGSTR_V10, NSPR_SIGSIZE_V10);
nspr_abstime_v10_t abs10;
/* populate the record */
- val16 = htoles(NSPR_ABSTIME_V10);
+ val16 = GUINT16_TO_LE(NSPR_ABSTIME_V10);
memcpy(abs10.phd.ph_RecordType, &val16, sizeof abs10.phd.ph_RecordType);
- val16 = htoles(nspr_abstime_v10_s);
+ val16 = GUINT16_TO_LE(nspr_abstime_v10_s);
memcpy(abs10.phd.ph_RecordSize, &val16, sizeof abs10.phd.ph_RecordSize);
memcpy(&reltime, ((const nspr_pktracefull_v10_t *)pd)->fp_RelTimeHr, sizeof reltime);
nsg_creltime = ns_hrtime2nsec(reltime);
memset(abs10.abs_RelTime, 0, sizeof abs10.abs_RelTime);
- abstime = htolel((guint32)phdr->ts.secs - (guint32)(nsg_creltime/1000000000));
+ abstime = GUINT32_TO_LE((guint32)phdr->ts.secs - (guint32)(nsg_creltime/1000000000));
memcpy(abs10.abs_Time, &abstime, sizeof abs10.abs_Time);
/* Write the record into the file */
nsg_creltime = ns_hrtime2nsec(reltime);
memset(abs20.abs_RelTime, 0, sizeof abs20.abs_RelTime);
- abstime = htolel((guint32)phdr->ts.secs - (guint32)(nsg_creltime/1000000000));
+ abstime = GUINT32_TO_LE((guint32)phdr->ts.secs - (guint32)(nsg_creltime/1000000000));
memcpy(abs20.abs_RelTime, &abstime, sizeof abs20.abs_RelTime);
/* Write the record into the file */
timestamp = ((guint64)phdr->ts.secs - (guint64)netxray->start.secs)*1000000
+ ((guint64)phdr->ts.nsecs)/1000;
t32 = (guint32)(timestamp%G_GINT64_CONSTANT(4294967296));
- rec_hdr.timelo = htolel(t32);
+ rec_hdr.timelo = GUINT32_TO_LE(t32);
t32 = (guint32)(timestamp/G_GINT64_CONSTANT(4294967296));
- rec_hdr.timehi = htolel(t32);
- rec_hdr.orig_len = htoles(phdr->len);
- rec_hdr.incl_len = htoles(phdr->caplen);
+ rec_hdr.timehi = GUINT32_TO_LE(t32);
+ rec_hdr.orig_len = GUINT16_TO_LE(phdr->len);
+ rec_hdr.incl_len = GUINT16_TO_LE(phdr->caplen);
if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof(rec_hdr), err))
return FALSE;
/* "sniffer" version ? */
memset(&file_hdr, '\0', sizeof file_hdr);
memcpy(file_hdr.version, vers_1_1, sizeof vers_1_1);
- file_hdr.start_time = htolel(netxray->start.secs);
- file_hdr.nframes = htolel(netxray->nframes);
- file_hdr.start_offset = htolel(CAPTUREFILE_HEADER_SIZE);
+ file_hdr.start_time = GUINT32_TO_LE(netxray->start.secs);
+ file_hdr.nframes = GUINT32_TO_LE(netxray->nframes);
+ file_hdr.start_offset = GUINT32_TO_LE(CAPTUREFILE_HEADER_SIZE);
/* XXX - large files? */
- file_hdr.end_offset = htolel((guint32)filelen);
+ file_hdr.end_offset = GUINT32_TO_LE((guint32)filelen);
file_hdr.network = wtap_encap_to_netxray_1_1_encap(wdh->encap);
- file_hdr.timelo = htolel(0);
- file_hdr.timehi = htolel(0);
+ file_hdr.timelo = GUINT32_TO_LE(0);
+ file_hdr.timehi = GUINT32_TO_LE(0);
memset(hdr_buf, '\0', sizeof hdr_buf);
memcpy(hdr_buf, &file_hdr, sizeof(file_hdr));
timestamp = ((guint64)phdr->ts.secs - (guint64)netxray->start.secs)*1000000
+ ((guint64)phdr->ts.nsecs)/1000;
t32 = (guint32)(timestamp%G_GINT64_CONSTANT(4294967296));
- rec_hdr.timelo = htolel(t32);
+ rec_hdr.timelo = GUINT32_TO_LE(t32);
t32 = (guint32)(timestamp/G_GINT64_CONSTANT(4294967296));
- rec_hdr.timehi = htolel(t32);
- rec_hdr.orig_len = htoles(phdr->len);
- rec_hdr.incl_len = htoles(phdr->caplen);
+ rec_hdr.timehi = GUINT32_TO_LE(t32);
+ rec_hdr.orig_len = GUINT16_TO_LE(phdr->len);
+ rec_hdr.incl_len = GUINT16_TO_LE(phdr->caplen);
switch (phdr->pkt_encap) {
/* "sniffer" version ? */
memset(&file_hdr, '\0', sizeof file_hdr);
memcpy(file_hdr.version, vers_2_001, sizeof vers_2_001);
- file_hdr.start_time = htolel(netxray->start.secs);
- file_hdr.nframes = htolel(netxray->nframes);
- file_hdr.start_offset = htolel(CAPTUREFILE_HEADER_SIZE);
+ file_hdr.start_time = GUINT32_TO_LE(netxray->start.secs);
+ file_hdr.nframes = GUINT32_TO_LE(netxray->nframes);
+ file_hdr.start_offset = GUINT32_TO_LE(CAPTUREFILE_HEADER_SIZE);
/* XXX - large files? */
- file_hdr.end_offset = htolel((guint32)filelen);
+ file_hdr.end_offset = GUINT32_TO_LE((guint32)filelen);
file_hdr.network = wtap_encap_to_netxray_2_0_encap(wdh->encap);
- file_hdr.timelo = htolel(0);
- file_hdr.timehi = htolel(0);
+ file_hdr.timelo = GUINT32_TO_LE(0);
+ file_hdr.timehi = GUINT32_TO_LE(0);
switch (wdh->encap) {
case WTAP_ENCAP_PPP_WITH_PHDR:
/* "sniffer" version ? */
maj_vers = 4;
min_vers = 0;
- version.maj_vers = htoles(maj_vers);
- version.min_vers = htoles(min_vers);
+ version.maj_vers = GUINT16_TO_LE(maj_vers);
+ version.min_vers = GUINT16_TO_LE(min_vers);
version.time = 0;
- version.date = htoles(start_date);
+ version.date = GUINT16_TO_LE(start_date);
version.type = 4;
version.network = wtap_encap[wdh->encap];
version.format = 1;
t_low = (guint16)((t >> 0) & 0xFFFF);
t_med = (guint16)((t >> 16) & 0xFFFF);
t_high = (guint8)((t >> 32) & 0xFF);
- rec_hdr.time_low = htoles(t_low);
- rec_hdr.time_med = htoles(t_med);
+ rec_hdr.time_low = GUINT16_TO_LE(t_low);
+ rec_hdr.time_med = GUINT16_TO_LE(t_med);
rec_hdr.time_high = t_high;
- rec_hdr.size = htoles(phdr->caplen);
+ rec_hdr.size = GUINT16_TO_LE(phdr->caplen);
switch (wdh->encap) {
case WTAP_ENCAP_LAPB:
break;
}
rec_hdr.flags = 0;
- rec_hdr.true_size = phdr->len != phdr->caplen ? htoles(phdr->len) : 0;
+ rec_hdr.true_size = phdr->len != phdr->caplen ? GUINT16_TO_LE(phdr->len) : 0;
rec_hdr.rsvd = 0;
if (!wtap_dump_file_write(wdh, &rec_hdr, sizeof rec_hdr, err))
return FALSE;
return (*err != 0) ? -1 : 0;
}
- if (htolel(magic) != TNEF_SIGNATURE)
+ if (GUINT32_TO_LE(magic) != TNEF_SIGNATURE)
/* Not a tnef file */
return 0;
/* Calculate milliseconds since capture start. */
delta_msec = phdr->ts.nsecs / 1000000;
delta_msec += ( (guint32) phdr->ts.secs - visual->start_time) * 1000;
- vpkt_hdr.ts_delta = htolel(delta_msec);
+ vpkt_hdr.ts_delta = GUINT32_TO_LE(delta_msec);
/* Fill in the length fields. */
- vpkt_hdr.orig_len = htoles(phdr->len);
- vpkt_hdr.incl_len = htoles(phdr->caplen);
+ vpkt_hdr.orig_len = GUINT16_TO_LE(phdr->len);
+ vpkt_hdr.incl_len = GUINT16_TO_LE(phdr->caplen);
/* Fill in the encapsulation hint for the file's media type. */
switch (wdh->encap)
((pseudo_header->x25.flags & FROM_DCE) ? 0x00 : PS_SENT);
break;
}
- vpkt_hdr.status = htolel(packet_status);
+ vpkt_hdr.status = GUINT32_TO_LE(packet_status);
/* Write the packet header. */
if (!wtap_dump_file_write(wdh, &vpkt_hdr, hdr_size, err))
visual->index_table = (guint32 *)g_realloc(visual->index_table,
visual->index_table_size * sizeof *visual->index_table);
}
- visual->index_table[visual->index_table_index] = htolel(visual->next_offset);
+ visual->index_table[visual->index_table_index] = GUINT32_TO_LE(visual->next_offset);
/* Update the table index and offset for the next frame. */
visual->index_table_index++;
/* Initialize the file header with zeroes for the reserved fields. */
memset(&vfile_hdr, '\0', sizeof vfile_hdr);
- vfile_hdr.num_pkts = htolel(visual->index_table_index);
- vfile_hdr.start_time = htolel(visual->start_time);
- vfile_hdr.max_length = htoles(65535);
- vfile_hdr.file_flags = htoles(1); /* indexes are present */
- vfile_hdr.file_version = htoles(1);
+ vfile_hdr.num_pkts = GUINT32_TO_LE(visual->index_table_index);
+ vfile_hdr.start_time = GUINT32_TO_LE(visual->start_time);
+ vfile_hdr.max_length = GUINT16_TO_LE(65535);
+ vfile_hdr.file_flags = GUINT16_TO_LE(1); /* indexes are present */
+ vfile_hdr.file_version = GUINT16_TO_LE(1);
g_strlcpy(vfile_hdr.description, "Wireshark file", 64);
/* Translate the encapsulation type */
switch (wdh->encap)
{
case WTAP_ENCAP_ETHERNET:
- vfile_hdr.media_type = htoles(6);
+ vfile_hdr.media_type = GUINT16_TO_LE(6);
break;
case WTAP_ENCAP_TOKEN_RING:
- vfile_hdr.media_type = htoles(9);
+ vfile_hdr.media_type = GUINT16_TO_LE(9);
break;
case WTAP_ENCAP_LAPB:
- vfile_hdr.media_type = htoles(16);
+ vfile_hdr.media_type = GUINT16_TO_LE(16);
break;
case WTAP_ENCAP_PPP: /* PPP is differentiated from CHDLC in PktHdr */
case WTAP_ENCAP_PPP_WITH_PHDR:
case WTAP_ENCAP_CHDLC_WITH_PHDR:
- vfile_hdr.media_type = htoles(22);
+ vfile_hdr.media_type = GUINT16_TO_LE(22);
break;
case WTAP_ENCAP_FRELAY_WITH_PHDR:
- vfile_hdr.media_type = htoles(32);
+ vfile_hdr.media_type = GUINT16_TO_LE(32);
break;
}
(p)[0] = tmp; \
}
-/* Turn host-byte-order values into little-endian values. */
-#define htoles(s) GUINT16_TO_LE(s)
-#define htolel(l) GUINT32_TO_LE(l)
-#define htolell(ll) GUINT64_TO_LE(ll)
-
/* Pointer versions of ntohs and ntohl. Given a pointer to a member of a
* byte array, returns the value of the two or four bytes at the pointer.
* The pletoh[sl] versions return the little-endian representation.
((((x)&0xFF00)>>8) | \
(((x)&0x00FF)<<8))
-/* Turn host-byte-order values into little-endian values. */
-#define htoles(s) GUINT16_TO_LE(s)
-#define htolel(l) GUINT32_TO_LE(l)
-
#endif /* PINT_H */
git.samba.org / metze / wireshark / wip.git / commitdiff