/* Swap 4- of bytes.
*/
static void
vips_copy_swap4( VipsPel *in, VipsPel *out, int width, VipsImage *im )
{
guint32 *p = (guint32 *) in;
guint32 *q = (guint32 *) out;
int sz = (VIPS_IMAGE_SIZEOF_PEL( im ) * width) / 4;
int x;
for( x = 0; x < sz; x++ )
q[x] = GUINT32_SWAP_LE_BE( p[x] );
}
/*
* IEEE 802.x version (Ethernet and 802.11, at least) - byte-swap
* the result of "crc32()".
*
* XXX - does this mean we should fetch the Ethernet and 802.11
* FCS with "tvb_get_letohl()" rather than "tvb_get_ntohl()",
* or is fetching it big-endian and byte-swapping the CRC done
* to cope with 802.x sending stuff out in reverse bit order?
*/
guint32
crc32_802_tvb(tvbuff_t *tvb, guint len)
{
guint32 c_crc;
c_crc = crc32_ccitt_tvb(tvb, len);
/* Byte reverse. */
c_crc = GUINT32_SWAP_LE_BE(c_crc);
return ( c_crc );
}
static gboolean
giop_recv_msg_reading_body (GIOPRecvBuffer *buf,
gboolean is_auth)
{
dprintf (GIOP, "Incoming IIOP header:\n");
do_giop_dump (stderr, (guint8 *) &buf->msg.header, 12, 0);
/* Check the header */
if (memcmp (buf->msg.header.magic, "GIOP", 4))
return TRUE;
if (buf->msg.header.message_type >= GIOP_NUM_MSG_TYPES)
return TRUE;
switch (buf->msg.header.version [0]) {
case 1:
switch (buf->msg.header.version [1]) {
case 0:
buf->giop_version = GIOP_1_0;
break;
case 1:
buf->giop_version = GIOP_1_1;
break;
case 2:
buf->giop_version = GIOP_1_2;
break;
default:
return TRUE;
break;
}
break;
default:
return TRUE;
break;
}
if ((buf->msg.header.flags & GIOP_FLAG_LITTLE_ENDIAN) != GIOP_FLAG_ENDIANNESS)
buf->msg.header.message_size = GUINT32_SWAP_LE_BE (buf->msg.header.message_size);
/* NB. at least CLOSECONNECTION has 0 length message_size */
if (!is_auth && buf->msg.header.message_size > giop_initial_msg_size_limit) {
dprintf (ERRORS, "Message exceeded unauthorized size limit\n");
return TRUE;
}
if (alloc_buffer (buf, NULL, buf->msg.header.message_size))
return TRUE;
return FALSE;
}
void
_ORBIT_skel_Freeamp_PlayNumber(POA_Freeamp * _ORBIT_servant,
GIOPRecvBuffer * _ORBIT_recv_buffer,
CORBA_Environment * ev,
void (*_impl_PlayNumber)
(PortableServer_Servant _servant,
const CORBA_char * number,
CORBA_Environment * ev))
{
CORBA_char *number;
{ /* demarshalling */
guchar *_ORBIT_curptr;
register CORBA_unsigned_long _ORBIT_tmpvar_2;
CORBA_unsigned_long _ORBIT_tmpvar_3;
_ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
_ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
(*((guint32 *) & (_ORBIT_tmpvar_3))) =
GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
_ORBIT_curptr += 4;
number = (void *) _ORBIT_curptr;
_ORBIT_curptr += sizeof(number[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
} else {
_ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
_ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
_ORBIT_curptr += 4;
number = (void *) _ORBIT_curptr;
_ORBIT_curptr += sizeof(number[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
}
}
_impl_PlayNumber(_ORBIT_servant, number, ev);
{ /* marshalling */
register GIOPSendBuffer *_ORBIT_send_buffer;
_ORBIT_send_buffer =
giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
connection, NULL,
_ORBIT_recv_buffer->message.u.request.
request_id, ev->_major);
if (_ORBIT_send_buffer) {
if (ev->_major == CORBA_NO_EXCEPTION) {
} else
ORBit_send_system_exception(_ORBIT_send_buffer, ev);
giop_send_buffer_write(_ORBIT_send_buffer);
giop_send_buffer_unuse(_ORBIT_send_buffer);
}
}
}
static gboolean
giop_recv_buffer_demarshal_locate_reply_1_1(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 8) > buf->end)
return TRUE;
if (do_bswap) {
buf->msg.u.locate_reply_1_1.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
buf->cur += 4;
buf->msg.u.locate_reply_1_1.locate_status = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
} else {
buf->msg.u.locate_reply_1_1.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
buf->msg.u.locate_reply_1_1.locate_status = *((guint32 *)buf->cur);
}
buf->cur += 4;
return FALSE;
}
static void draw_rect_BGRA(
guchar *pixels[3],
guint stride[3],
gint x,
gint y,
guint width,
guint height,
guint32 color
)
{
// Converts ARGB color to BGRA
color = GUINT32_SWAP_LE_BE(color);
draw_rect_ARGB(pixels, stride, x, y, width, height, color);
}
const int32_t *pcm_byteswap_32(struct pcm_buffer *buffer,
const int32_t *src, size_t len)
{
int32_t *buf = pcm_buffer_get(buffer, len);
assert(buf != NULL);
const int32_t *src_end = src + len / sizeof(*src);
int32_t *dest = buf;
while (src < src_end) {
const int32_t x = *src++;
*dest++ = GUINT32_SWAP_LE_BE(x);
}
return buf;
}
static gboolean
giop_recv_buffer_demarshal_cancel(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed (buf);
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
return TRUE;
if (do_bswap)
buf->msg.u.cancel_request.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.cancel_request.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
return FALSE;
}
/* Don't do this genericaly, union's suck genericaly */
static gboolean
giop_GIOP_TargetAddress_demarshal (GIOPRecvBuffer *buf,
GIOP_TargetAddress *value)
{
gboolean do_bswap = giop_msg_conversion_needed (buf);
buf->cur = ALIGN_ADDRESS(buf->cur, 2);
if ((buf->cur + 2) > buf->end)
return TRUE;
if (do_bswap)
value->_d = GUINT16_SWAP_LE_BE (
*(guint16 *) buf->cur);
else
value->_d = *(guint16 *) buf->cur;
buf->cur += 2;
switch (value->_d) {
case GIOP_KeyAddr:
buf->cur = ALIGN_ADDRESS (buf->cur, 4);
if ((buf->cur + 4) > buf->end)
return TRUE;
value->_u.object_key._release = CORBA_FALSE;
if (do_bswap)
value->_u.object_key._length = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
value->_u.object_key._length = *((guint32 *)buf->cur);
buf->cur += 4;
if ((buf->cur + value->_u.object_key._length) > buf->end ||
(buf->cur + value->_u.object_key._length) < buf->cur)
return TRUE;
value->_u.object_key._buffer = buf->cur;
buf->cur += value->_u.object_key._length;
break;
case GIOP_ProfileAddr:
g_warning ("XXX FIXME GIOP_ProfileAddr not handled");
return TRUE;
break;
case GIOP_ReferenceAddr:
g_warning ("XXX FIXME GIOP_ReferenceAddr not handled");
return TRUE;
break;
}
return FALSE;
}
static gboolean
giop_recv_buffer_demarshal_locate_request_1_2(GIOPRecvBuffer *buf)
{
gboolean do_bswap = giop_msg_conversion_needed(buf);
buf->cur = ALIGN_ADDRESS(buf->cur, 4);
if((buf->cur + 4) > buf->end)
return TRUE;
if(do_bswap)
buf->msg.u.locate_request_1_2.request_id = GUINT32_SWAP_LE_BE(*((guint32 *)buf->cur));
else
buf->msg.u.locate_request_1_2.request_id = *((guint32 *)buf->cur);
buf->cur += 4;
return giop_GIOP_TargetAddress_demarshal (buf, &buf->msg.u.locate_request_1_2.target);
}
static gboolean
match_info_to_ip4_addr (GMatchInfo *match_info,
guint match_index,
guint *out_addr)
{
gchar *s, *bin = NULL;
gchar buf[9];
gsize len, bin_len;
gboolean success = FALSE;
s = g_match_info_fetch (match_info, match_index);
g_return_val_if_fail (s != NULL, FALSE);
len = strlen (s);
if (len == 1 && s[0] == '0') {
*out_addr = 0;
success = TRUE;
goto done;
}
if (len < 7 || len > 8)
goto done;
/* Handle possibly missing leading zero */
memset (buf, 0, sizeof (buf));
if (len == 7) {
strcpy (&buf[1], s);
buf[0] = '0';
} else if (len == 8)
strcpy (buf, s);
else
g_assert_not_reached ();
bin = mm_utils_hexstr2bin (buf, &bin_len);
if (!bin || bin_len != 4)
goto done;
*out_addr = GUINT32_SWAP_LE_BE (*((guint32 *) bin));
success = TRUE;
done:
g_free (s);
g_free (bin);
return success;
}
static gboolean
as_app_builder_parse_file_gettext (AsAppBuilderContext *ctx,
const gchar *locale,
const gchar *filename,
GError **error)
{
AsAppBuilderEntry *entry;
AsAppBuilderGettextHeader h;
g_autofree gchar *data = NULL;
gboolean swapped;
/* read data */
if (!g_file_get_contents (filename, &data, NULL, error))
return FALSE;
/* we only strictly need the header */
memcpy (&h, data, sizeof (AsAppBuilderGettextHeader));
if (h.magic == 0x950412de)
swapped = FALSE;
else if (h.magic == 0xde120495)
swapped = TRUE;
else {
g_set_error_literal (error,
AS_APP_ERROR,
AS_APP_ERROR_FAILED,
"file is invalid");
return FALSE;
}
entry = as_app_builder_entry_new ();
entry->locale = g_strdup (locale);
if (swapped)
entry->nstrings = GUINT32_SWAP_LE_BE (h.nstrings);
else
entry->nstrings = h.nstrings;
if (entry->nstrings > ctx->max_nstrings)
ctx->max_nstrings = entry->nstrings;
ctx->data = g_list_prepend (ctx->data, entry);
return TRUE;
}
static gboolean
capture_enc(const guchar *pd, int offset _U_, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header)
{
guint32 af;
if (!BYTES_ARE_IN_FRAME(0, len, BSD_ENC_HDRLEN))
return FALSE;
memcpy((char *)&af, (const char *)&pd[0], sizeof(af));
if ((af & 0xFFFF0000) != 0) {
/*
* BSD AF_ types will always have the upper 16 bits as 0, so if any
* of them are non-zero, the af field must be byte-swapped, and
* will, at least in DLT_ENC headers, always have at least one of
* the lower 16 bits not being 0 (it won't be AF_UNSPEC, which is
* 0), so if the af field is byte-swapped, at least one of the
* upper 16 bits will be 0.
*/
af = GUINT32_SWAP_LE_BE(af);
}
return try_capture_dissector("enc", af, pd, BSD_ENC_HDRLEN, len, cpinfo, pseudo_header);
}
static inline gboolean
_read_metadata(SerializeArchive *sa, NVTableMetaData *meta_data)
{
if (!_read_magic(sa, &meta_data->magic))
{
return FALSE;
}
if (!_read_flags(sa, &meta_data->flags))
{
return FALSE;
}
if (_has_to_swap_bytes(meta_data->flags))
{
meta_data->magic = GUINT32_SWAP_LE_BE(meta_data->magic);
}
if (memcmp((void *)&meta_data->magic, (const void *)NV_TABLE_MAGIC_V2, 4) != 0)
{
return FALSE;
}
return TRUE;
}
WSLUA_METHOD TvbRange_le_ipv4(lua_State* L) {
/* Get an Little Endian IPv4 Address from a `TvbRange`, as an `Address` object. */
TvbRange tvbr = checkTvbRange(L,1);
Address addr;
guint32 ip_addr;
if ( !(tvbr && tvbr->tvb)) return 0;
if (tvbr->tvb->expired) {
luaL_error(L,"expired tvb");
return 0;
}
if (tvbr->len != 4) {
WSLUA_ERROR(TvbRange_ipv4,"The range must be 4 octets long");
return 0;
}
addr = g_new(address,1);
ip_addr = GUINT32_SWAP_LE_BE(tvb_get_ipv4(tvbr->tvb->ws_tvb,tvbr->offset));
alloc_address_wmem(NULL, addr, AT_IPv4, sizeof(ip_addr), &ip_addr);
pushAddress(L,addr);
WSLUA_RETURN(1); /* The IPv4 `Address` object. */
}
* 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 48-bit value as little-endian
*---------------------------------------------------*/
static gboolean s48write(wtap_dumper *wdh, const guint64 s48, int *err)
{
#ifdef WORDS_BIGENDIAN
guint16 s48_upper_le = GUINT16_SWAP_LE_BE((guint16) (s48 >> 32));
guint32 s48_lower_le = GUINT32_SWAP_LE_BE((guint32) (s48 & 0xFFFFFFFF));
#else
guint16 s48_upper_le = (guint16) (s48 >> 32);
guint32 s48_lower_le = (guint32) (s48 & 0xFFFFFFFF);
#endif
return wtap_dump_file_write(wdh, &s48_lower_le, 4, err) &&
wtap_dump_file_write(wdh, &s48_upper_le, 2, err);
}
/*---------------------------------------------------
* 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, gchar **err_info _U_)
{
int
main (int argc,
char *argv[])
{
gchar *string;
gushort gus;
guint gui;
gulong gul;
gsize gsz;
gshort gs;
gint gi;
glong gl;
gint16 gi16t1;
gint16 gi16t2;
gint32 gi32t1;
gint32 gi32t2;
guint16 gu16t1 = 0x44afU, gu16t2 = 0xaf44U;
guint32 gu32t1 = 0x02a7f109U, gu32t2 = 0x09f1a702U;
guint64 gu64t1 = G_GINT64_CONSTANT(0x1d636b02300a7aa7U),
gu64t2 = G_GINT64_CONSTANT(0xa77a0a30026b631dU);
gint64 gi64t1;
gint64 gi64t2;
gssize gsst1;
gssize gsst2;
gsize gst1;
gsize gst2;
#ifdef SYMBIAN
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*SYMBIAN*/
/* type sizes */
g_assert (sizeof (gint8) == 1);
g_assert (sizeof (gint16) == 2);
g_assert (sizeof (gint32) == 4);
g_assert (sizeof (gint64) == 8);
g_assert (GUINT16_SWAP_LE_BE (gu16t1) == gu16t2);
g_assert (GUINT32_SWAP_LE_BE (gu32t1) == gu32t2);
g_assert (GUINT64_SWAP_LE_BE (gu64t1) == gu64t2);
/* Test the G_(MIN|MAX|MAXU)(SHORT|INT|LONG) macros */
gus = G_MAXUSHORT;
gus++;
g_assert (gus == 0);
gui = G_MAXUINT;
gui++;
g_assert (gui == 0);
gul = G_MAXULONG;
gul++;
g_assert (gul == 0);
gsz = G_MAXSIZE;
gsz++;
g_assert (gsz == 0);
gs = G_MAXSHORT;
gs++;
g_assert (gs == G_MINSHORT);
gi = G_MAXINT;
gi++;
g_assert (gi == G_MININT);
gl = G_MAXLONG;
gl++;
g_assert (gl == G_MINLONG);
/* Test the G_G(U)?INT(16|32|64)_FORMAT macros */
gi16t1 = -0x3AFA;
gu16t1 = 0xFAFA;
gi32t1 = -0x3AFAFAFA;
gu32t1 = 0xFAFAFAFA;
#define FORMAT "%" G_GINT16_FORMAT " %" G_GINT32_FORMAT \
" %" G_GUINT16_FORMAT " %" G_GUINT32_FORMAT "\n"
string = g_strdup_printf (FORMAT, gi16t1, gi32t1, gu16t1, gu32t1);
sscanf (string, FORMAT, &gi16t2, &gi32t2, &gu16t2, &gu32t2);
g_free (string);
g_assert (gi16t1 == gi16t2);
g_assert (gi32t1 == gi32t2);
g_assert (gu16t1 == gu16t2);
g_assert (gu32t1 == gu32t2);
gi64t1 = G_GINT64_CONSTANT (-0x3AFAFAFAFAFAFAFA);
gu64t1 = G_GINT64_CONSTANT (0xFAFAFAFAFAFAFAFA);
#define FORMAT64 "%" G_GINT64_FORMAT " %" G_GUINT64_FORMAT "\n"
string = g_strdup_printf (FORMAT64, gi64t1, gu64t1);
sscanf (string, FORMAT64, &gi64t2, &gu64t2);
g_free (string);
g_assert (gi64t1 == gi64t2);
g_assert (gu64t1 == gu64t2);
gsst1 = -0x3AFAFAFA;
gst1 = 0xFAFAFAFA;
#define FORMATSIZE "%" G_GSSIZE_FORMAT " %" G_GSIZE_FORMAT "\n"
string = g_strdup_printf (FORMATSIZE, gsst1, gst1);
sscanf (string, FORMATSIZE, &gsst2, &gst2);
g_free (string);
g_assert (gsst1 == gsst2);
g_assert (gst1 == gst2);
#ifdef SYMBIAN
testResultXml("type-test");
#endif /* EMULATOR */
return 0;
}
/* Read the header of the next packet.
Return FALSE on an error, TRUE on success. */
static int libpcap_read_header(wtap *wth, FILE_T fh, int *err, gchar **err_info,
struct pcaprec_ss990915_hdr *hdr)
{
int bytes_to_read;
guint32 temp;
libpcap_t *libpcap;
switch (wth->file_type_subtype) {
case WTAP_FILE_TYPE_SUBTYPE_PCAP:
case WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX:
case WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC:
bytes_to_read = sizeof (struct pcaprec_hdr);
break;
case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417:
case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029:
bytes_to_read = sizeof (struct pcaprec_modified_hdr);
break;
case WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915:
bytes_to_read = sizeof (struct pcaprec_ss990915_hdr);
break;
case WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA:
bytes_to_read = sizeof (struct pcaprec_nokia_hdr);
break;
default:
g_assert_not_reached();
bytes_to_read = 0;
}
if (!wtap_read_bytes_or_eof(fh, hdr, bytes_to_read, err, err_info))
return FALSE;
libpcap = (libpcap_t *)wth->priv;
if (libpcap->byte_swapped) {
/* Byte-swap the record header fields. */
hdr->hdr.ts_sec = GUINT32_SWAP_LE_BE(hdr->hdr.ts_sec);
hdr->hdr.ts_usec = GUINT32_SWAP_LE_BE(hdr->hdr.ts_usec);
hdr->hdr.incl_len = GUINT32_SWAP_LE_BE(hdr->hdr.incl_len);
hdr->hdr.orig_len = GUINT32_SWAP_LE_BE(hdr->hdr.orig_len);
}
/* Swap the "incl_len" and "orig_len" fields, if necessary. */
switch (libpcap->lengths_swapped) {
case NOT_SWAPPED:
break;
case MAYBE_SWAPPED:
if (hdr->hdr.incl_len <= hdr->hdr.orig_len) {
/*
* The captured length is <= the actual length,
* so presumably they weren't swapped.
*/
break;
}
/* FALLTHROUGH */
case SWAPPED:
temp = hdr->hdr.orig_len;
hdr->hdr.orig_len = hdr->hdr.incl_len;
hdr->hdr.incl_len = temp;
break;
}
return TRUE;
}
wtap_open_return_val libpcap_open(wtap *wth, int *err, gchar **err_info)
{
guint32 magic;
struct pcap_hdr hdr;
gboolean byte_swapped;
gboolean modified;
gboolean aix;
int file_encap;
gint64 first_packet_offset;
libpcap_t *libpcap;
static const int subtypes_modified[] = {
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS991029,
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990915
};
#define N_SUBTYPES_MODIFIED G_N_ELEMENTS(subtypes_modified)
static const int subtypes_standard[] = {
WTAP_FILE_TYPE_SUBTYPE_PCAP,
WTAP_FILE_TYPE_SUBTYPE_PCAP_SS990417,
WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA
};
#define N_SUBTYPES_STANDARD G_N_ELEMENTS(subtypes_standard)
static const int subtypes_nsec[] = {
WTAP_FILE_TYPE_SUBTYPE_PCAP_NSEC
};
#define N_SUBTYPES_NSEC G_N_ELEMENTS(subtypes_nsec)
#define MAX_FIGURES_OF_MERIT \
MAX(MAX(N_SUBTYPES_MODIFIED, N_SUBTYPES_STANDARD), N_SUBTYPES_NSEC)
int figures_of_merit[MAX_FIGURES_OF_MERIT];
const int *subtypes;
int n_subtypes;
int best_subtype;
int i;
/* Read in the number that should be at the start of a "libpcap" file */
if (!wtap_read_bytes(wth->fh, &magic, sizeof magic, err, err_info)) {
if (*err != WTAP_ERR_SHORT_READ)
return WTAP_OPEN_ERROR;
return WTAP_OPEN_NOT_MINE;
}
switch (magic) {
case PCAP_MAGIC:
/* Host that wrote it has our byte order, and was running
a program using either standard or ss990417 libpcap. */
byte_swapped = FALSE;
modified = FALSE;
wth->file_tsprec = WTAP_TSPREC_USEC;
break;
case PCAP_MODIFIED_MAGIC:
/* Host that wrote it has our byte order, and was running
a program using either ss990915 or ss991029 libpcap. */
byte_swapped = FALSE;
modified = TRUE;
wth->file_tsprec = WTAP_TSPREC_USEC;
break;
case PCAP_SWAPPED_MAGIC:
/* Host that wrote it has a byte order opposite to ours,
and was running a program using either standard or
ss990417 libpcap. */
byte_swapped = TRUE;
modified = FALSE;
wth->file_tsprec = WTAP_TSPREC_USEC;
break;
case PCAP_SWAPPED_MODIFIED_MAGIC:
/* Host that wrote it out has a byte order opposite to
ours, and was running a program using either ss990915
or ss991029 libpcap. */
byte_swapped = TRUE;
modified = TRUE;
wth->file_tsprec = WTAP_TSPREC_USEC;
break;
case PCAP_NSEC_MAGIC:
/* Host that wrote it has our byte order, and was writing
the file in a format similar to standard libpcap
except that the time stamps have nanosecond resolution. */
byte_swapped = FALSE;
modified = FALSE;
wth->file_tsprec = WTAP_TSPREC_NSEC;
break;
case PCAP_SWAPPED_NSEC_MAGIC:
/* Host that wrote it out has a byte order opposite to
ours, and was writing the file in a format similar to
standard libpcap except that the time stamps have
nanosecond resolution. */
byte_swapped = TRUE;
modified = FALSE;
wth->file_tsprec = WTAP_TSPREC_NSEC;
break;
default:
/* Not a "libpcap" type we know about. */
return WTAP_OPEN_NOT_MINE;
}
/* Read the rest of the header. */
if (!wtap_read_bytes(wth->fh, &hdr, sizeof hdr, err, err_info))
return WTAP_OPEN_ERROR;
if (byte_swapped) {
/* Byte-swap the header fields about which we care. */
hdr.version_major = GUINT16_SWAP_LE_BE(hdr.version_major);
hdr.version_minor = GUINT16_SWAP_LE_BE(hdr.version_minor);
hdr.snaplen = GUINT32_SWAP_LE_BE(hdr.snaplen);
hdr.network = GUINT32_SWAP_LE_BE(hdr.network);
}
if (hdr.version_major < 2) {
/* We only support version 2.0 and later. */
*err = WTAP_ERR_UNSUPPORTED;
*err_info = g_strdup_printf("pcap: major version %u unsupported",
hdr.version_major);
return WTAP_OPEN_ERROR;
}
/*
* AIX's non-standard tcpdump uses a minor version number of 2.
* Unfortunately, older versions of libpcap might have used
* that as well.
*
* The AIX libpcap uses RFC 1573 ifType values rather than
* DLT_ values in the header; the ifType values for LAN devices
* are:
*
* Ethernet 6
* Token Ring 9
* FDDI 15
*
* which correspond to DLT_IEEE802 (used for Token Ring),
* DLT_PPP, and DLT_SLIP_BSDOS, respectively. The ifType value
* for a loopback interface is 24, which currently isn't
* used by any version of libpcap I know about (and, as
* tcpdump.org are assigning DLT_ values above 100, and
* NetBSD started assigning values starting at 50, and
* the values chosen by other libpcaps appear to stop at
* 19, it's probably not going to be used by any libpcap
* in the future).
*
* We shall assume that if the minor version number is 2, and
* the network type is 6, 9, 15, or 24, that it's AIX libpcap.
*
* I'm assuming those older versions of libpcap didn't
* use DLT_IEEE802 for Token Ring, and didn't use DLT_SLIP_BSDOS
* as that came later. It may have used DLT_PPP, however, in
* which case we're out of luck; we assume it's Token Ring
* in AIX libpcap rather than PPP in standard libpcap, as
* you're probably more likely to be handing an AIX libpcap
* token-ring capture than an old (pre-libpcap 0.4) PPP capture
* to Wireshark.
*/
aix = FALSE; /* assume it's not AIX */
if (hdr.version_major == 2 && hdr.version_minor == 2) {
switch (hdr.network) {
case 6:
hdr.network = 1; /* DLT_EN10MB, Ethernet */
aix = TRUE;
break;
case 9:
hdr.network = 6; /* DLT_IEEE802, Token Ring */
aix = TRUE;
break;
case 15:
hdr.network = 10; /* DLT_FDDI, FDDI */
aix = TRUE;
break;
case 24:
hdr.network = 0; /* DLT_NULL, loopback */
aix = TRUE;
break;
}
}
file_encap = wtap_pcap_encap_to_wtap_encap(hdr.network);
if (file_encap == WTAP_ENCAP_UNKNOWN) {
*err = WTAP_ERR_UNSUPPORTED;
*err_info = g_strdup_printf("pcap: network type %u unknown or unsupported",
hdr.network);
return WTAP_OPEN_ERROR;
}
/* This is a libpcap file */
libpcap = (libpcap_t *)g_malloc(sizeof(libpcap_t));
libpcap->byte_swapped = byte_swapped;
libpcap->version_major = hdr.version_major;
libpcap->version_minor = hdr.version_minor;
wth->priv = (void *)libpcap;
wth->subtype_read = libpcap_read;
wth->subtype_seek_read = libpcap_seek_read;
wth->file_encap = file_encap;
wth->snapshot_length = hdr.snaplen;
/* In file format version 2.3, the order of the "incl_len" and
"orig_len" fields in the per-packet header was reversed,
in order to match the BPF header layout.
Therefore, in files with versions prior to that, we must swap
those two fields.
Unfortunately, some files were, according to a comment in the
"libpcap" source, written with version 2.3 in their headers
but without the interchanged fields, so if "incl_len" is
greater than "orig_len" - which would make no sense - we
assume that we need to swap them in version 2.3 files
as well.
In addition, DG/UX's tcpdump uses version 543.0, and writes
the two fields in the pre-2.3 order. */
switch (hdr.version_major) {
case 2:
if (hdr.version_minor < 3)
libpcap->lengths_swapped = SWAPPED;
else if (hdr.version_minor == 3)
libpcap->lengths_swapped = MAYBE_SWAPPED;
else
libpcap->lengths_swapped = NOT_SWAPPED;
break;
case 543:
libpcap->lengths_swapped = SWAPPED;
break;
default:
libpcap->lengths_swapped = NOT_SWAPPED;
break;
}
/*
* Is this AIX format?
*/
if (aix) {
/*
* Yes. Skip all the tests for other mutant formats,
* and for the ERF link-layer header type, and set the
* precision to nanosecond precision.
*/
wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PCAP_AIX;
wth->file_tsprec = WTAP_TSPREC_NSEC;
return WTAP_OPEN_MINE;
}
/*
* No. Let's look at the header for the first record,
* and see if, interpreting it as a standard header (if the
* magic number was standard) or a modified header (if the
* magic number was modified), the position where it says the
* header for the *second* record is contains a corrupted header.
*
* If so, then:
*
* If this file had the standard magic number, it may be
* an ss990417 capture file - in that version of Alexey's
* patch, the packet header format was changed but the
* magic number wasn't, and, alas, Red Hat appear to have
* picked up that version of the patch for RH 6.1, meaning
* RH 6.1 has a tcpdump that writes out files that can't
* be read by any software that expects non-modified headers
* if the magic number isn't the modified magic number (e.g.,
* any normal version of tcpdump, and Wireshark if we don't
* do this gross heuristic).
*
* If this file had the modified magic number, it may be
* an ss990915 capture file - in that version of Alexey's
* patch, the magic number was changed, but the record
* header had some extra fields, and, alas, SuSE appear
* to have picked up that version of the patch for SuSE
* 6.3, meaning that programs expecting the standard per-
* packet header in captures with the modified magic number
* can't read dumps from its tcpdump.
*
* Oh, and if it has the standard magic number, it might, instead,
* be a Nokia libpcap file, so we may need to try that if
* neither normal nor ss990417 headers work.
*/
if (modified) {
/*
* Well, we have the magic number from Alexey's
* later two patches. Try the subtypes for that.
*/
subtypes = subtypes_modified;
n_subtypes = N_SUBTYPES_MODIFIED;
} else {
if (wth->file_tsprec == WTAP_TSPREC_NSEC) {
/*
* We have nanosecond-format libpcap's magic
* number. Try the subtypes for that.
*/
subtypes = subtypes_nsec;
n_subtypes = N_SUBTYPES_NSEC;
} else {
/*
* We have the regular libpcap magic number.
* Try the subtypes for that.
*/
subtypes = subtypes_standard;
n_subtypes = N_SUBTYPES_STANDARD;
}
}
/*
* Try all the subtypes.
*/
first_packet_offset = file_tell(wth->fh);
for (i = 0; i < n_subtypes; i++) {
wth->file_type_subtype = subtypes[i];
figures_of_merit[i] = libpcap_try(wth, err, err_info);
if (figures_of_merit[i] == -1) {
/*
* Well, we couldn't even read it.
* Give up.
*/
return WTAP_OPEN_ERROR;
}
if (figures_of_merit[i] == 0) {
/*
* This format doesn't have any issues.
* Put the seek pointer back, and finish.
*/
if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
return WTAP_OPEN_ERROR;
}
goto done;
}
/*
* OK, we've recorded the figure of merit for this one;
* go back to the first packet and try the next one.
*/
if (file_seek(wth->fh, first_packet_offset, SEEK_SET, err) == -1) {
return WTAP_OPEN_ERROR;
}
}
/*
* OK, none are perfect; let's see which one is least bad.
*/
best_subtype = INT_MAX;
for (i = 0; i < n_subtypes; i++) {
/*
* Is this subtype better than the last one we saw?
*/
if (figures_of_merit[i] < best_subtype) {
/*
* Yes. Choose it until we find a better one.
*/
wth->file_type_subtype = subtypes[i];
best_subtype = figures_of_merit[i];
}
}
done:
/*
* We treat a DLT_ value of 13 specially - it appears that in
* Nokia libpcap format, it's some form of ATM with what I
* suspect is a pseudo-header (even though Nokia's IPSO is
* based on FreeBSD, which #defines DLT_SLIP_BSDOS as 13).
*
* If this is a Nokia capture, treat 13 as WTAP_ENCAP_ATM_PDUS,
* rather than as what we normally treat it.
*/
if (wth->file_type_subtype == WTAP_FILE_TYPE_SUBTYPE_PCAP_NOKIA &&
hdr.network == 13)
wth->file_encap = WTAP_ENCAP_ATM_PDUS;
if (wth->file_encap == WTAP_ENCAP_ERF) {
/*
* Populate set of interface IDs for ERF format.
* Currently, this *has* to be done at open time.
*/
erf_populate_interfaces(wth);
}
return WTAP_OPEN_MINE;
}
void bu256_copy_swap(bu256_t *vo, const bu256_t *vi)
{
unsigned int i;
for (i = 0; i < 8; i++)
vo->dword[i] = GUINT32_SWAP_LE_BE(vi->dword[i]);
}
void bu256_swap(bu256_t *v)
{
unsigned int i;
for (i = 0; i < 8; i++)
v->dword[i] = GUINT32_SWAP_LE_BE(v->dword[i]);
}
int
DemarshalSimpleTypes( int byte_order, tMarshalType type,
void *data, const void *buffer )
{
switch( type )
{
case eMtVoid:
return 0;
case eMtUint8:
case eMtInt8:
{
tUint8 v = *(const tUint8 *)buffer;
*(tUint8 *)data = v;
}
return sizeof( tUint8 );
case eMtInt16:
case eMtUint16:
{
tUint16 v;
memcpy( &v, buffer, sizeof( tUint16 ) );
if ( G_BYTE_ORDER != byte_order )
v = GUINT16_SWAP_LE_BE( v );
*(tUint16 *)data = v;
}
return sizeof( tUint16 );
case eMtUint32:
case eMtInt32:
{
tUint32 v;
memcpy( &v, buffer, sizeof( tUint32 ) );
if ( G_BYTE_ORDER != byte_order )
v = GUINT32_SWAP_LE_BE( v );
*(tUint32 *)data = v;
}
return sizeof( tUint32 );
case eMtUint64:
case eMtInt64:
{
tUint64 v;
memcpy( &v, buffer, sizeof( tUint64 ) );
if ( G_BYTE_ORDER != byte_order )
v = GUINT64_SWAP_LE_BE( v );
*(tUint64 *)data = v;
}
return sizeof( tUint64 );
case eMtFloat32:
{
// this has been tested for i386 and PPC
tFloat32Uint32 v;
memcpy( &(v.m_f32), buffer, sizeof( tFloat32 ) );
if ( G_BYTE_ORDER != byte_order )
v.m_u32 = GUINT32_SWAP_LE_BE( v.m_u32 );
*(tFloat32 *)data = v.m_f32;
}
return sizeof( tFloat32 );
case eMtFloat64:
{
// this has been tested for i386 and PPC
tFloat64Uint64 v;
memcpy( &(v.m_f64), buffer, sizeof( tFloat64 ) );
if ( G_BYTE_ORDER != byte_order )
v.m_u64 = GUINT64_SWAP_LE_BE( v.m_u64 );
*(tFloat64 *)data = v.m_f64;
}
return sizeof( tFloat64 );
default:
break;
}
assert( 0 );
return -1;
}
int
main( int argc, char *argv[] )
{
int i;
// float 32
WriteFile( "Float32.bin", float32_data, sizeof( float32_data ) );
tFloat32 f32[sizeof( float32_data ) / sizeof( tFloat32 )];
ReadFile( "Float32.bin", f32, sizeof( float32_data ) );
if ( memcmp( float32_data, f32, sizeof( float32_data ) ) )
{
fprintf( stderr, "read/write float 32 error !\n" );
return 1;
}
// float 64
WriteFile( "Float64.bin", float64_data, sizeof( float64_data ) );
tFloat64 f64[sizeof( float64_data ) / sizeof( tFloat64 )];
ReadFile( "Float64.bin", f64, sizeof( float64_data ) );
if ( memcmp( float64_data, f64, sizeof( float64_data ) ) )
{
fprintf( stderr, "read/write float 64 error !\n" );
return 1;
}
// conversion
if ( G_BYTE_ORDER == G_LITTLE_ENDIAN )
ReadFile( "Float32.bin.ppc", f32, sizeof( float32_data ) );
else
ReadFile( "Float32.bin.i386", f32, sizeof( float32_data ) );
char *p = (char *)f32;
for( i = 0; i < float32_data_num; i++, p += sizeof( tFloat32 ) )
{
/* compile error */
// unsigned int v = *(unsigned int *)p;
unsigned int v = *(unsigned int *)(void *)p;
v = GUINT32_SWAP_LE_BE( v );
/* compile error */
// *(unsigned int *)p = v;
*(unsigned int *)(void *)p = v;
}
if ( memcmp( float32_data, f32, sizeof( float32_data ) ) )
{
fprintf( stderr, "byteswap float 32 fail !\n" );
return 1;
}
// conversion
if ( G_BYTE_ORDER == G_LITTLE_ENDIAN )
ReadFile( "Float64.bin.ppc", f64, sizeof( float64_data ) );
else
ReadFile( "Float64.bin.i386", f64, sizeof( float64_data ) );
p = (char *)f64;
for( i = 0; i < float64_data_num; i++, p += sizeof( tFloat64 ) )
{
/* compile error */
// unsigned long long v = *(unsigned long long *)p;
unsigned long long v = *(unsigned long long *)(void *)p;
v = GUINT64_SWAP_LE_BE( v );
/* compile error */
// *(unsigned long long *)p = v;
*(unsigned long long *)(void *)p = v;
}
if ( memcmp( float64_data, f64, sizeof( float64_data ) ) )
{
fprintf( stderr, "byteswap float 64 fail !\n" );
return 1;
}
return 0;
}
static GstCaps *
gst_fbdevsink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstFBDEVSink *fbdevsink;
GstVideoFormat format;
GstCaps *caps;
uint32_t rmask;
uint32_t gmask;
uint32_t bmask;
uint32_t tmask;
int endianness, depth, bpp;
fbdevsink = GST_FBDEVSINK (bsink);
caps = gst_static_pad_template_get_caps (&sink_template);
/* FIXME: locking */
if (!fbdevsink->framebuffer)
goto done;
bpp = fbdevsink->varinfo.bits_per_pixel;
rmask = ((1 << fbdevsink->varinfo.red.length) - 1)
<< fbdevsink->varinfo.red.offset;
gmask = ((1 << fbdevsink->varinfo.green.length) - 1)
<< fbdevsink->varinfo.green.offset;
bmask = ((1 << fbdevsink->varinfo.blue.length) - 1)
<< fbdevsink->varinfo.blue.offset;
tmask = ((1 << fbdevsink->varinfo.transp.length) - 1)
<< fbdevsink->varinfo.transp.offset;
depth = fbdevsink->varinfo.red.length + fbdevsink->varinfo.green.length
+ fbdevsink->varinfo.blue.length;
switch (fbdevsink->varinfo.bits_per_pixel) {
case 32:
/* swap endianness of masks */
rmask = GUINT32_SWAP_LE_BE (rmask);
gmask = GUINT32_SWAP_LE_BE (gmask);
bmask = GUINT32_SWAP_LE_BE (bmask);
tmask = GUINT32_SWAP_LE_BE (tmask);
depth += fbdevsink->varinfo.transp.length;
endianness = G_BIG_ENDIAN;
break;
case 24:{
/* swap red and blue masks */
tmask = rmask;
rmask = bmask;
bmask = tmask;
tmask = 0;
endianness = G_BIG_ENDIAN;
break;
}
case 15:
case 16:
tmask = 0;
endianness = G_LITTLE_ENDIAN;
break;
default:
goto unsupported_bpp;
}
format = gst_video_format_from_masks (depth, bpp, endianness, rmask, gmask,
bmask, tmask);
if (format == GST_VIDEO_FORMAT_UNKNOWN)
goto unknown_format;
caps = gst_caps_make_writable (caps);
gst_caps_set_simple (caps, "format", G_TYPE_STRING,
gst_video_format_to_string (format), NULL);
done:
if (filter != NULL) {
GstCaps *icaps;
icaps = gst_caps_intersect (caps, filter);
gst_caps_unref (caps);
caps = icaps;
}
return caps;
/* ERRORS */
unsupported_bpp:
{
GST_WARNING_OBJECT (bsink, "unsupported bit depth: %d", bpp);
return NULL;
}
unknown_format:
{
GST_WARNING_OBJECT (bsink, "could not map fbdev format to GstVideoFormat: "
"depth=%u, bpp=%u, endianness=%u, rmask=0x%08x, gmask=0x%08x, "
"bmask=0x%08x, tmask=0x%08x", depth, bpp, endianness, rmask, gmask,
bmask, tmask);
return NULL;
}
}
/* Takes ownership of pixbuf; call with OBJECT_LOCK */
static void
gst_gdk_pixbuf_overlay_set_pixbuf (GstGdkPixbufOverlay * overlay,
GdkPixbuf * pixbuf)
{
GstVideoMeta *video_meta;
guint8 *pixels, *p;
gint width, height, stride, w, h, plane;
if (!gdk_pixbuf_get_has_alpha (pixbuf)) {
GdkPixbuf *alpha_pixbuf;
/* FIXME: we could do this much more efficiently ourselves below, but
* we're lazy for now */
/* FIXME: perhaps expose substitute_color via properties */
alpha_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
g_object_unref (pixbuf);
pixbuf = alpha_pixbuf;
}
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
stride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
/* the memory layout in GdkPixbuf is R-G-B-A, we want:
* - B-G-R-A on little-endian platforms
* - A-R-G-B on big-endian platforms
*/
for (h = 0; h < height; ++h) {
p = pixels + (h * stride);
for (w = 0; w < width; ++w) {
guint8 tmp;
/* R-G-B-A ==> B-G-R-A */
tmp = p[0];
p[0] = p[2];
p[2] = tmp;
if (G_BYTE_ORDER == G_BIG_ENDIAN) {
/* B-G-R-A ==> A-R-G-B */
/* we can probably assume sane alignment */
*((guint32 *) p) = GUINT32_SWAP_LE_BE (*((guint32 *) p));
}
p += 4;
}
}
/* assume we have row padding even for the last row */
/* transfer ownership of pixbuf to the buffer */
overlay->pixels = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
pixels, height * stride, 0, height * stride, pixbuf,
(GDestroyNotify) g_object_unref);
video_meta = gst_buffer_add_video_meta (overlay->pixels,
GST_VIDEO_FRAME_FLAG_NONE, GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB,
width, height);
for (plane = 0; plane < video_meta->n_planes; ++plane)
video_meta->stride[plane] = stride;
overlay->update_composition = TRUE;
GST_INFO_OBJECT (overlay, "Updated pixbuf, %d x %d", width, height);
}
gboolean
log_proto_buffered_server_restart_with_state(LogProtoServer *s, PersistState *persist_state, const gchar *persist_name)
{
LogProtoBufferedServer *self = (LogProtoBufferedServer *) s;
guint8 persist_version;
PersistEntryHandle old_state_handle;
gpointer old_state;
gsize old_state_size;
PersistEntryHandle new_state_handle = 0;
gpointer new_state = NULL;
gboolean success;
self->pos_tracking = TRUE;
self->persist_state = persist_state;
old_state_handle = persist_state_lookup_entry(persist_state, persist_name, &old_state_size, &persist_version);
if (!old_state_handle)
{
new_state_handle = log_proto_buffered_server_alloc_state(self, persist_state, persist_name);
if (!new_state_handle)
goto fallback_non_persistent;
log_proto_buffered_server_apply_state(self, new_state_handle, persist_name);
return TRUE;
}
if (persist_version < 4)
{
new_state_handle = log_proto_buffered_server_alloc_state(self, persist_state, persist_name);
if (!new_state_handle)
goto fallback_non_persistent;
old_state = persist_state_map_entry(persist_state, old_state_handle);
new_state = persist_state_map_entry(persist_state, new_state_handle);
success = log_proto_buffered_server_convert_state(self, persist_version, old_state, old_state_size, new_state);
persist_state_unmap_entry(persist_state, old_state_handle);
persist_state_unmap_entry(persist_state, new_state_handle);
/* we're using the newly allocated state structure regardless if
* conversion succeeded. If the conversion went wrong then
* new_state is still in its freshly initialized form since the
* convert function will not touch the state in the error
* branches.
*/
log_proto_buffered_server_apply_state(self, new_state_handle, persist_name);
return success;
}
else if (persist_version == 4)
{
LogProtoBufferedServerState *state;
old_state = persist_state_map_entry(persist_state, old_state_handle);
state = old_state;
if ((state->header.big_endian && G_BYTE_ORDER == G_LITTLE_ENDIAN) ||
(!state->header.big_endian && G_BYTE_ORDER == G_BIG_ENDIAN))
{
/* byte order conversion in order to avoid the hassle with
scattered byte order conversions in the code */
state->header.big_endian = !state->header.big_endian;
state->buffer_pos = GUINT32_SWAP_LE_BE(state->buffer_pos);
state->pending_buffer_pos = GUINT32_SWAP_LE_BE(state->pending_buffer_pos);
state->pending_buffer_end = GUINT32_SWAP_LE_BE(state->pending_buffer_end);
state->buffer_size = GUINT32_SWAP_LE_BE(state->buffer_size);
state->raw_stream_pos = GUINT64_SWAP_LE_BE(state->raw_stream_pos);
state->raw_buffer_size = GUINT32_SWAP_LE_BE(state->raw_buffer_size);
state->pending_raw_stream_pos = GUINT64_SWAP_LE_BE(state->pending_raw_stream_pos);
state->pending_raw_buffer_size = GUINT32_SWAP_LE_BE(state->pending_raw_buffer_size);
state->file_size = GUINT64_SWAP_LE_BE(state->file_size);
state->file_inode = GUINT64_SWAP_LE_BE(state->file_inode);
}
if (state->header.version > 0)
{
msg_error("Internal error restoring log reader state, stored data is too new",
evt_tag_int("version", state->header.version));
goto error;
}
persist_state_unmap_entry(persist_state, old_state_handle);
log_proto_buffered_server_apply_state(self, old_state_handle, persist_name);
return TRUE;
}
else
{
msg_error("Internal error restoring log reader state, stored data is too new",
evt_tag_int("version", persist_version));
goto error;
}
return TRUE;
fallback_non_persistent:
new_state = g_new0(LogProtoBufferedServerState, 1);
error:
if (!new_state)
{
new_state_handle = log_proto_buffered_server_alloc_state(self, persist_state, persist_name);
if (!new_state_handle)
goto fallback_non_persistent;
new_state = persist_state_map_entry(persist_state, new_state_handle);
}
if (new_state)
{
LogProtoBufferedServerState *state = new_state;
/* error happened, restart the file from the beginning */
state->raw_stream_pos = 0;
state->file_inode = 0;
state->file_size = 0;
if (new_state_handle)
log_proto_buffered_server_apply_state(self, new_state_handle, persist_name);
else
self->state1 = new_state;
}
if (new_state_handle)
{
persist_state_unmap_entry(persist_state, new_state_handle);
}
return FALSE;
}
dt_imageio_retval_t dt_imageio_open_pfm(dt_image_t *img, const char *filename, dt_mipmap_buffer_t *mbuf)
{
const char *ext = filename + strlen(filename);
while(*ext != '.' && ext > filename) ext--;
if(strcasecmp(ext, ".pfm")) return DT_IMAGEIO_FILE_CORRUPTED;
FILE *f = fopen(filename, "rb");
if(!f) return DT_IMAGEIO_FILE_CORRUPTED;
int ret = 0;
int cols = 3;
float scale_factor;
char head[2] = { 'X', 'X' };
ret = fscanf(f, "%c%c\n", head, head + 1);
if(ret != 2 || head[0] != 'P') goto error_corrupt;
if(head[1] == 'F')
cols = 3;
else if(head[1] == 'f')
cols = 1;
else
goto error_corrupt;
ret = fscanf(f, "%d %d %f%*[^\n]", &img->width, &img->height, &scale_factor);
if(ret != 3) goto error_corrupt;
ret = fread(&ret, sizeof(char), 1, f);
if(ret != 1) goto error_corrupt;
ret = 0;
int swap_byte_order = (scale_factor >= 0.0) ^ (G_BYTE_ORDER == G_BIG_ENDIAN);
float *buf = (float *)dt_mipmap_cache_alloc(mbuf, img);
if(!buf) goto error_cache_full;
if(cols == 3)
{
ret = fread(buf, 3 * sizeof(float), (size_t)img->width * img->height, f);
for(size_t i = (size_t)img->width * img->height; i > 0; i--)
for(int c = 0; c < 3; c++)
{
union { float f; guint32 i; } v;
v.f = buf[3 * (i - 1) + c];
if(swap_byte_order) v.i = GUINT32_SWAP_LE_BE(v.i);
buf[4 * (i - 1) + c] = fmaxf(0.0f, fminf(FLT_MAX, v.f));
}
}
else
for(size_t j = 0; j < img->height; j++)
for(size_t i = 0; i < img->width; i++)
{
union { float f; guint32 i; } v;
ret = fread(&v.f, sizeof(float), 1, f);
if(swap_byte_order) v.i = GUINT32_SWAP_LE_BE(v.i);
buf[4 * (img->width * j + i) + 2] = buf[4 * (img->width * j + i) + 1]
= buf[4 * (img->width * j + i) + 0] = v.f;
}
float *line = (float *)calloc(4 * img->width, sizeof(float));
for(size_t j = 0; j < img->height / 2; j++)
{
memcpy(line, buf + img->width * j * 4, 4 * sizeof(float) * img->width);
memcpy(buf + img->width * j * 4, buf + img->width * (img->height - 1 - j) * 4,
4 * sizeof(float) * img->width);
memcpy(buf + img->width * (img->height - 1 - j) * 4, line, 4 * sizeof(float) * img->width);
}
free(line);
fclose(f);
return DT_IMAGEIO_OK;
error_corrupt:
fclose(f);
return DT_IMAGEIO_FILE_CORRUPTED;
error_cache_full:
fclose(f);
return DT_IMAGEIO_CACHE_FULL;
}
static gboolean
i4b_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
i4btrace_t *i4btrace = (i4btrace_t *)wth->priv;
i4b_trace_hdr_t hdr;
guint32 length;
if (!wtap_read_bytes_or_eof(fh, &hdr, sizeof hdr, err, err_info))
return FALSE;
if (i4btrace->byte_swapped) {
/*
* Byte-swap the header.
*/
hdr.length = GUINT32_SWAP_LE_BE(hdr.length);
hdr.unit = GUINT32_SWAP_LE_BE(hdr.unit);
hdr.type = GUINT32_SWAP_LE_BE(hdr.type);
hdr.dir = GUINT32_SWAP_LE_BE(hdr.dir);
hdr.trunc = GUINT32_SWAP_LE_BE(hdr.trunc);
hdr.count = GUINT32_SWAP_LE_BE(hdr.count);
hdr.ts_sec = GUINT32_SWAP_LE_BE(hdr.ts_sec);
hdr.ts_usec = GUINT32_SWAP_LE_BE(hdr.ts_usec);
}
if (hdr.length < sizeof(hdr)) {
*err = WTAP_ERR_BAD_FILE; /* record length < header! */
*err_info = g_strdup_printf("i4btrace: record length %u < header length %lu",
hdr.length, (unsigned long)sizeof(hdr));
return FALSE;
}
length = hdr.length - (guint32)sizeof(hdr);
if (length > WTAP_MAX_PACKET_SIZE_STANDARD) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("i4btrace: File has %u-byte packet, bigger than maximum of %u",
length, WTAP_MAX_PACKET_SIZE_STANDARD);
return FALSE;
}
phdr->rec_type = REC_TYPE_PACKET;
phdr->presence_flags = WTAP_HAS_TS;
phdr->len = length;
phdr->caplen = length;
phdr->ts.secs = hdr.ts_sec;
phdr->ts.nsecs = hdr.ts_usec * 1000;
switch (hdr.type) {
case TRC_CH_I:
/*
* XXX - what is it? It's probably not WTAP_ENCAP_NULL,
* as that means it has a 4-byte AF_ type as the
* encapsulation header.
*/
phdr->pkt_encap = WTAP_ENCAP_NULL;
break;
case TRC_CH_D:
/*
* D channel, so it's LAPD; set "p2p.sent".
*/
phdr->pkt_encap = WTAP_ENCAP_ISDN;
phdr->pseudo_header.isdn.channel = 0;
break;
case TRC_CH_B1:
/*
* B channel 1.
*/
phdr->pkt_encap = WTAP_ENCAP_ISDN;
phdr->pseudo_header.isdn.channel = 1;
break;
case TRC_CH_B2:
/*
* B channel 2.
*/
phdr->pkt_encap = WTAP_ENCAP_ISDN;
phdr->pseudo_header.isdn.channel = 2;
break;
}
phdr->pseudo_header.isdn.uton = (hdr.dir == FROM_TE);
/*
* Read the packet data.
*/
return wtap_read_packet_bytes(fh, buf, length, err, err_info);
}
gboolean
qdisk_start(QDisk *self, const gchar *filename, GQueue *qout, GQueue *qbacklog, GQueue *qoverflow)
{
gboolean new_file = FALSE;
gpointer p = NULL;
int openflags = 0;
/*
* If qdisk_start is called for already initialized qdisk file
* it can cause message loosing.
* We need this assert to detect programming error as soon as possible.
*/
g_assert(!qdisk_initialized(self));
if (self->options->disk_buf_size <= 0)
return TRUE;
if (self->options->read_only && !filename)
return FALSE;
if (!filename)
{
new_file = TRUE;
/* NOTE: this'd be a security problem if we were not in our private directory. But we are. */
filename = _next_filename(self);
}
else
{
struct stat st;
if (stat(filename,&st) == -1)
{
new_file = TRUE;
}
}
self->filename = g_strdup(filename);
/* assumes self is zero initialized */
openflags = self->options->read_only ? (O_RDONLY | O_LARGEFILE) : (O_RDWR | O_LARGEFILE | (new_file ? O_CREAT : 0));
self->fd = open(filename, openflags, 0600);
if (self->fd < 0)
{
msg_error("Error opening disk-queue file",
evt_tag_str("filename", self->filename),
evt_tag_errno("error", errno));
return FALSE;
}
p = mmap(0, sizeof(QDiskFileHeader), self->options->read_only ? (PROT_READ) : (PROT_READ | PROT_WRITE), MAP_SHARED, self->fd, 0);
if (p == MAP_FAILED)
{
msg_error("Error returned by mmap",
evt_tag_errno("errno", errno),
evt_tag_str("filename", self->filename));
return FALSE;
}
else
{
madvise(p, sizeof(QDiskFileHeader), MADV_RANDOM);
}
if (self->options->read_only)
{
self->hdr = g_malloc(sizeof(QDiskFileHeader));
memcpy(self->hdr, p, sizeof(QDiskFileHeader));
munmap(p, sizeof(QDiskFileHeader) );
p = NULL;
}
else
{
self->hdr = p;
}
/* initialize new file */
if (new_file)
{
QDiskFileHeader tmp;
memset(&tmp, 0, sizeof(tmp));
if (!pwrite_strict(self->fd, &tmp, sizeof(tmp), 0))
{
msg_error("Error occured while initalizing the new queue file",evt_tag_str("filename",self->filename),evt_tag_errno("error",errno));
munmap((void *)self->hdr, sizeof(QDiskFileHeader));
self->hdr = NULL;
close(self->fd);
self->fd = -1;
return FALSE;
}
self->hdr->version = 1;
self->hdr->big_endian = (G_BYTE_ORDER == G_BIG_ENDIAN);
self->hdr->read_head = QDISK_RESERVED_SPACE;
self->hdr->write_head = QDISK_RESERVED_SPACE;
self->hdr->backlog_head = self->hdr->read_head;
self->hdr->length = 0;
if (!qdisk_save_state(self, qout, qbacklog, qoverflow))
{
munmap((void *)self->hdr, sizeof(QDiskFileHeader));
self->hdr = NULL;
close(self->fd);
self->fd = -1;
return FALSE;
}
}
else
{
struct stat st;
if (fstat(self->fd, &st) != 0 || st.st_size == 0)
{
msg_error("Error loading disk-queue file",
evt_tag_str("filename", self->filename),
evt_tag_errno("fstat error", errno),
evt_tag_int("size", st.st_size));
munmap((void *)self->hdr, sizeof(QDiskFileHeader));
self->hdr = NULL;
close(self->fd);
self->fd = -1;
return FALSE;
}
if (self->hdr->version == 0)
{
self->hdr->big_endian = TRUE;
self->hdr->version = 1;
self->hdr->backlog_head = self->hdr->read_head;
self->hdr->backlog_len = 0;
}
if ((self->hdr->big_endian && G_BYTE_ORDER == G_LITTLE_ENDIAN) ||
(!self->hdr->big_endian && G_BYTE_ORDER == G_BIG_ENDIAN))
{
self->hdr->read_head = GUINT64_SWAP_LE_BE(self->hdr->read_head);
self->hdr->write_head = GUINT64_SWAP_LE_BE(self->hdr->write_head);
self->hdr->length = GUINT64_SWAP_LE_BE(self->hdr->length);
self->hdr->qout_ofs = GUINT64_SWAP_LE_BE(self->hdr->qout_ofs);
self->hdr->qout_len = GUINT32_SWAP_LE_BE(self->hdr->qout_len);
self->hdr->qout_count = GUINT32_SWAP_LE_BE(self->hdr->qout_count);
self->hdr->qbacklog_ofs = GUINT64_SWAP_LE_BE(self->hdr->qbacklog_ofs);
self->hdr->qbacklog_len = GUINT32_SWAP_LE_BE(self->hdr->qbacklog_len);
self->hdr->qbacklog_count = GUINT32_SWAP_LE_BE(self->hdr->qbacklog_count);
self->hdr->qoverflow_ofs = GUINT64_SWAP_LE_BE(self->hdr->qoverflow_ofs);
self->hdr->qoverflow_len = GUINT32_SWAP_LE_BE(self->hdr->qoverflow_len);
self->hdr->qoverflow_count = GUINT32_SWAP_LE_BE(self->hdr->qoverflow_count);
self->hdr->backlog_head = GUINT64_SWAP_LE_BE(self->hdr->backlog_head);
self->hdr->backlog_len = GUINT64_SWAP_LE_BE(self->hdr->backlog_len);
self->hdr->big_endian = (G_BYTE_ORDER == G_BIG_ENDIAN);
}
if (!_load_state(self, qout, qbacklog, qoverflow))
{
munmap((void *)self->hdr, sizeof(QDiskFileHeader));
self->hdr = NULL;
close(self->fd);
self->fd = -1;
return FALSE;
}
}
return TRUE;
}
/*
Read TilEm skin informations (header)
*/
int skin_read_header(SKIN_INFOS *si, FILE *fp)
{
int i;
uint32_t endian;
uint32_t jpeg_offset;
uint32_t length;
char str[17];
/* signature & offsets */
fread(str, 16, 1, fp);
if ((strncmp(str, "TilEm v2.00", 16))
&& (strncmp(str, "TiEmu v2.00", 16))) {
return -1;
}
fread(&endian, 4, 1, fp);
fread(&jpeg_offset, 4, 1, fp);
if (endian != ENDIANNESS_FLAG)
jpeg_offset = GUINT32_SWAP_LE_BE(jpeg_offset);
/* Skin name */
fread(&length, 4, 1, fp);
if (endian != ENDIANNESS_FLAG)
length = GUINT32_SWAP_LE_BE(length);
if (length > 0) {
si->name = (char *)malloc(length + 1);
if (si->name == NULL)
return -1;
memset(si->name, 0, length + 1);
fread(si->name, length, 1, fp);
}
/* Skin author */
fread(&length, 4, 1, fp);
if (endian != ENDIANNESS_FLAG)
length = GUINT32_SWAP_LE_BE(length);
if (length > 0) {
si->author = (char *)malloc(length + 1);
if (si->author == NULL)
return -1;
memset(si->author, 0, length + 1);
fread(si->author, length, 1, fp);
}
/* LCD colors */
fread(&si->colortype, 4, 1, fp);
fread(&si->lcd_white, 4, 1, fp);
fread(&si->lcd_black, 4, 1, fp);
/* Calc type */
fread(si->calc, 8, 1, fp);
/* LCD position */
fread(&si->lcd_pos.left, 4, 1, fp);
fread(&si->lcd_pos.top, 4, 1, fp);
fread(&si->lcd_pos.right, 4, 1, fp);
fread(&si->lcd_pos.bottom, 4, 1, fp);
/* Number of RECT struct to read */
fread(&length, 4, 1, fp);
if (endian != ENDIANNESS_FLAG)
length = GUINT32_SWAP_LE_BE(length);
if (length > SKIN_KEYS)
return -1;
for (i = 0; i < (int)length; i++) {
fread(&si->keys_pos[i].left, 4, 1, fp);
fread(&si->keys_pos[i].top, 4, 1, fp);
fread(&si->keys_pos[i].right, 4, 1, fp);
fread(&si->keys_pos[i].bottom, 4, 1, fp);
}
if (endian != ENDIANNESS_FLAG) {
si->colortype = GUINT32_SWAP_LE_BE(si->colortype);
si->lcd_white = GUINT32_SWAP_LE_BE(si->lcd_white);
si->lcd_black = GUINT32_SWAP_LE_BE(si->lcd_black);
si->lcd_pos.top = GUINT32_SWAP_LE_BE(si->lcd_pos.top);
si->lcd_pos.left = GUINT32_SWAP_LE_BE(si->lcd_pos.left);
si->lcd_pos.bottom = GUINT32_SWAP_LE_BE(si->lcd_pos.bottom);
si->lcd_pos.right = GUINT32_SWAP_LE_BE(si->lcd_pos.right);
for (i = 0; i < (int)length; i++) {
si->keys_pos[i].top = GUINT32_SWAP_LE_BE(si->keys_pos[i].top);
si->keys_pos[i].bottom = GUINT32_SWAP_LE_BE(si->keys_pos[i].bottom);
si->keys_pos[i].left = GUINT32_SWAP_LE_BE(si->keys_pos[i].left);
si->keys_pos[i].right = GUINT32_SWAP_LE_BE(si->keys_pos[i].right);
}
}
si->jpeg_offset = ftell(fp);
return 0;
}
