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;
}
static int bt_string2uuid(uuid_t *uuid, const char *string)
{
uint32_t data0, data4;
uint16_t data1, data2, data3, data5;
if (sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
&data0, &data1, &data2, &data3, &data4, &data5) == 6) {
uint8_t val[16];
data0 = g_htonl(data0);
data1 = g_htons(data1);
data2 = g_htons(data2);
data3 = g_htons(data3);
data4 = g_htonl(data4);
data5 = g_htons(data5);
memcpy(&val[0], &data0, 4);
memcpy(&val[4], &data1, 2);
memcpy(&val[6], &data2, 2);
memcpy(&val[8], &data3, 2);
memcpy(&val[10], &data4, 4);
memcpy(&val[14], &data5, 2);
sdp_uuid128_create(uuid, val);
return 0;
}
return -EINVAL;
}
ArvGvcpPacket *
arv_gvcp_packet_new_packet_resend_cmd (guint32 frame_id,
guint32 first_block, guint32 last_block,
guint16 packet_id, size_t *packet_size)
{
ArvGvcpPacket *packet;
guint32 *data;
g_return_val_if_fail (packet_size != NULL, NULL);
*packet_size = sizeof (ArvGvcpHeader) + 3 * sizeof (guint32);
packet = g_malloc (*packet_size);
packet->header.packet_type = g_htons (ARV_GVCP_PACKET_TYPE_RESEND);
packet->header.command = g_htons (ARV_GVCP_COMMAND_PACKET_RESEND_CMD);
packet->header.size = g_htons (3 * sizeof (guint32));
packet->header.id = g_htons (packet_id);
data = (guint32 *) &packet->data;
data[0] = g_htonl (frame_id);
data[1] = g_htonl (first_block);
data[2] = g_htonl (last_block);
return packet;
}
ArvGvcpPacket *
arv_gvcp_packet_new_write_register_cmd (guint32 address,
guint32 value,
guint16 packet_id,
size_t *packet_size)
{
ArvGvcpPacket *packet;
guint32 n_address = g_htonl (address);
guint32 n_value = g_htonl (value);
g_return_val_if_fail (packet_size != NULL, NULL);
*packet_size = sizeof (ArvGvcpHeader) + 2 * sizeof (guint32);
packet = g_malloc (*packet_size);
packet->header.packet_type = g_htons (ARV_GVCP_PACKET_TYPE_CMD);
packet->header.command = g_htons (ARV_GVCP_COMMAND_WRITE_REGISTER_CMD);
packet->header.size = g_htons (2 * sizeof (guint32));
packet->header.id = g_htons (packet_id);
memcpy (&packet->data, &n_address, sizeof (guint32));
memcpy (&packet->data[sizeof (guint32)], &n_value, sizeof (guint32));
return packet;
}
/*
* Write a header to the current output file.
* The header consists of an identifying string, followed
* by a binary structure.
*/
void rtp_write_header(rtp_stream_info_t *strinfo, FILE *file)
{
guint32 start_sec; /* start of recording (GMT) (seconds) */
guint32 start_usec; /* start of recording (GMT) (microseconds)*/
guint32 source; /* network source (multicast address) */
size_t sourcelen;
guint16 port; /* UDP port */
guint16 padding; /* 2 padding bytes */
fprintf(file, "#!rtpplay%s %s/%u\n", RTPFILE_VERSION,
get_addr_name(&(strinfo->dest_addr)),
strinfo->dest_port);
start_sec = g_htonl(strinfo->start_sec);
start_usec = g_htonl(strinfo->start_usec);
/* rtpdump only accepts guint32 as source, will be fake for IPv6 */
memset(&source, 0, sizeof source);
sourcelen = strinfo->src_addr.len;
if (sourcelen > sizeof source)
sourcelen = sizeof source;
memcpy(&source, strinfo->src_addr.data, sourcelen);
port = g_htons(strinfo->src_port);
padding = 0;
if (fwrite(&start_sec, 4, 1, file) == 0)
return;
if (fwrite(&start_usec, 4, 1, file) == 0)
return;
if (fwrite(&source, 4, 1, file) == 0)
return;
if (fwrite(&port, 2, 1, file) == 0)
return;
if (fwrite(&padding, 2, 1, file) == 0)
return;
}
static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const guint8 *pd, int *err) {
const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
guint32 len;
union {
guint8 buffer[8192];
struct {
guint32 len;
guint32 type;
guint32 frame_len;
guint32 input;
guint32 datum_1;
guint32 datum_2;
guint64 ts;
guint8 frame[0x1fc0];
} record;
} obj;
/* We can only write packet records. */
if (phdr->rec_type != REC_TYPE_PACKET) {
*err = WTAP_ERR_REC_TYPE_UNSUPPORTED;
return FALSE;
}
if (k12->num_of_records == 0) {
k12_t* file_data = (k12_t*)pseudo_header->k12.stuff;
/* XXX: We'll assume that any fwrite errors in k12_dump_src_setting will */
/* repeat during the final k12_dump_record at the end of k12_dump */
/* (and thus cause an error return from k12_dump). */
/* (I don't see a reasonably clean way to handle any fwrite errors */
/* encountered in k12_dump_src_setting). */
g_hash_table_foreach(file_data->src_by_id,k12_dump_src_setting,wdh);
}
obj.record.len = 0x20 + phdr->caplen;
obj.record.len += (obj.record.len % 4) ? 4 - obj.record.len % 4 : 0;
len = obj.record.len;
obj.record.len = g_htonl(obj.record.len);
obj.record.type = g_htonl(K12_REC_PACKET);
obj.record.frame_len = g_htonl(phdr->caplen);
obj.record.input = g_htonl(pseudo_header->k12.input);
obj.record.ts = GUINT64_TO_BE((((guint64)phdr->ts.secs - 631152000) * 2000000) + (phdr->ts.nsecs / 1000 * 2));
memcpy(obj.record.frame,pd,phdr->caplen);
return k12_dump_record(wdh,len,obj.buffer, err);
}
static gboolean
sink_next_uint32 (SerialSink* sink, guint32 num)
{
num = g_htonl (num);
return sink->sink_write (sink, (guint8*) &num, sizeof (num));
}
void
rtp_packet_set_ssrc(Rtp_Packet packet, guint32 ssrc)
{
g_return_if_fail(packet != NULL);
((Rtp_Header) packet -> data) -> ssrc = g_htonl(ssrc);
}
guint
xcf_write_int32 (FILE *fp,
const guint32 *data,
gint count,
GError **error)
{
GError *tmp_error = NULL;
gint i;
if (count > 0)
{
for (i = 0; i < count; i++)
{
guint32 tmp = g_htonl (data[i]);
xcf_write_int8 (fp, (const guint8 *) &tmp, 4, &tmp_error);
if (tmp_error)
{
g_propagate_error (error, tmp_error);
return i * 4;
}
}
}
return count * 4;
}
static void gfire_sq_gamespy_query(gfire_game_server *p_server, gboolean p_full, int p_socket)
{
static const gchar info_query[] = "\\info\\";
static const gchar rules_query[] = "\\rules\\";
static const gchar players_query[] = "\\players\\";
const gchar *query = NULL;
if(!p_server->data)
query = info_query;
else
{
gfire_sq_gamespy_data *data = (gfire_sq_gamespy_data*)p_server->data->proto_data;
if(data->query_stage == GFSQ_GAMESPY_STAGE_RULES && !data->query_id)
query = rules_query;
else if(data->query_stage == GFSQ_GAMESPY_STAGE_PLAYERS && !data->query_id)
query = players_query;
else
return;
}
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = g_htonl(p_server->ip);
addr.sin_port = g_htons(p_server->query_port);
sendto(p_socket, query, strlen(query), 0, (struct sockaddr*)&addr, sizeof(addr));
}
static ArvGvspPacket *
arv_gvsp_packet_new (ArvGvspContentType content_type,
guint16 frame_id, guint32 packet_id, size_t data_size, void *buffer, size_t *buffer_size)
{
ArvGvspPacket *packet;
size_t packet_size;
packet_size = sizeof (ArvGvspPacket) + data_size;
if (packet_size == 0 || (buffer != NULL && (buffer_size == NULL || packet_size > *buffer_size)))
return NULL;
if (buffer_size != NULL)
*buffer_size = packet_size;
if (buffer != NULL)
packet = buffer;
else
packet = g_malloc (packet_size);
packet->header.packet_type = 0;
packet->header.frame_id = g_htons (frame_id);
packet->header.packet_infos = g_htonl ((packet_id & ARV_GVSP_PACKET_INFOS_ID_MASK) |
((content_type << ARV_GVSP_PACKET_INFOS_CONTENT_TYPE_POS) &
ARV_GVSP_PACKET_INFOS_CONTENT_TYPE_MASK));
return packet;
}
static void
gstring_append_int (GString *gstring,
guint32 vuint)
{
vuint = g_htonl (vuint);
g_string_append_len (gstring, (const gchar*) &vuint, 4);
}
static void
encode_macros_request (gpointer key, gpointer value, gpointer user_data)
{
MilterCommand command = GPOINTER_TO_INT(key);
GList *symbols = value;
GString *buffer = user_data;
MilterMacroStage stage, normalized_stage;
gchar encoded_stage[sizeof(guint32)];
stage = milter_utils_command_to_macro_stage(command);
if (stage == -1) {
/* should emit 'error' signal? */
milter_error("[reply-encoder][error][macro] unknown command: '%c'",
command);
return;
}
normalized_stage = g_htonl(stage);
memcpy(encoded_stage, &normalized_stage, sizeof(encoded_stage));
g_string_append_len(buffer, encoded_stage, sizeof(encoded_stage));
g_string_append(buffer, symbols->data);
for (symbols = g_list_next(symbols);
symbols;
symbols = g_list_next(symbols)) {
g_string_append_c(buffer, ' ');
g_string_append(buffer, symbols->data);
}
g_string_append_c(buffer, '\0');
}
static gboolean
v4_v6_match (const struct sockaddr_in *a4,
const struct sockaddr_in6 *b6,
guint prefix)
{
struct sockaddr_in b4;
guint32 v4_numeric;
if (! IN6_IS_ADDR_V4MAPPED (&b6->sin6_addr)) {
return FALSE;
}
memset (&b4, 0, sizeof (b4));
v4_numeric = b6->sin6_addr.s6_addr[12] << 24 |
b6->sin6_addr.s6_addr[13] << 16 |
b6->sin6_addr.s6_addr[14] << 8 |
b6->sin6_addr.s6_addr[15];
b4.sin_addr.s_addr = g_htonl (v4_numeric);
if (prefix == 0 || prefix > 31) {
return v4_v4_equal (a4, &b4);
}
return v4_v4_match (a4, &b4, prefix);
}
static GstBufferListItem
set_timestamp_header (GstBuffer ** buffer, guint group, guint idx,
guint32 * timestamp)
{
GST_RTP_HEADER_TIMESTAMP (GST_BUFFER_DATA (*buffer)) = g_htonl (*timestamp);
return GST_BUFFER_LIST_SKIP_GROUP;
}
void
rtp_packet_set_timestamp(Rtp_Packet packet, guint32 timestamp)
{
g_return_if_fail(packet != NULL);
((Rtp_Header) packet -> data) -> timestamp = g_htonl(timestamp);
}
static void
gstring_overwrite_int (GString *gstring,
guint pos,
guint32 vuint)
{
vuint = g_htonl (vuint);
g_string_overwrite_len (gstring, pos, (const gchar*) &vuint, 4);
}
EXPORT_C
#endif
void
gst_rtp_buffer_set_timestamp (GstBuffer * buffer, guint32 timestamp)
{
GST_RTP_HEADER_TIMESTAMP (GST_BUFFER_DATA (buffer)) = g_htonl (timestamp);
}
EXPORT_C
#endif
void
gst_rtp_buffer_set_ssrc (GstBuffer * buffer, guint32 ssrc)
{
GST_RTP_HEADER_SSRC (GST_BUFFER_DATA (buffer)) = g_htonl (ssrc);
}
static ArvStream *
arv_gv_device_create_stream (ArvDevice *device, ArvStreamCallback callback, void *user_data)
{
ArvGvDevice *gv_device = ARV_GV_DEVICE (device);
ArvGvDeviceIOData *io_data = gv_device->priv->io_data;
ArvStream *stream;
const guint8 *address_bytes;
guint32 stream_port;
guint packet_size;
guint32 n_stream_channels;
GInetAddress *interface_address;
GInetAddress *device_address;
arv_device_read_register (device, ARV_GVBS_N_STREAM_CHANNELS_OFFSET, &n_stream_channels, NULL);
arv_debug_device ("[GvDevice::create_stream] Number of stream channels = %d", n_stream_channels);
if (n_stream_channels < 1)
return NULL;
if (!io_data->is_controller) {
arv_warning_device ("[GvDevice::create_stream] Can't create stream without control access");
return NULL;
}
interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->interface_address));
device_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->device_address));
address_bytes = g_inet_address_to_bytes (interface_address);
/* On some cameras, the default packet size after reset is incorrect.
* So, if the value is obviously incorrect, set it to a default size. */
packet_size = arv_gv_device_get_packet_size (gv_device);
if (packet_size <= ARV_GVSP_PACKET_PROTOCOL_OVERHEAD) {
arv_gv_device_set_packet_size (gv_device, ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT);
arv_debug_device ("[GvDevice::create_stream] Packet size set to default value (%d)",
ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT);
}
packet_size = arv_gv_device_get_packet_size (gv_device);
arv_debug_device ("[GvDevice::create_stream] Packet size = %d byte(s)", packet_size);
stream = arv_gv_stream_new (device_address, 0, callback, user_data,
arv_gv_device_get_timestamp_tick_frequency (gv_device), packet_size);
stream_port = arv_gv_stream_get_port (ARV_GV_STREAM (stream));
if (!arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_IP_ADDRESS_OFFSET,
g_htonl(*((guint32 *) address_bytes)), NULL) ||
!arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_PORT_OFFSET, stream_port, NULL)) {
arv_warning_device ("[GvDevice::create_stream] Stream configuration failed");
g_object_unref (stream);
return NULL;
}
arv_debug_device ("[GvDevice::create_stream] Stream port = %d", stream_port);
return stream;
}
static
struct pgm_sk_buff_t*
generate_udp_encap_pgm (void)
{
const char source[] = "i am not a string";
const guint source_len = sizeof(source);
struct pgm_sk_buff_t* skb;
GError* err = NULL;
skb = pgm_alloc_skb (1500);
skb->sock = (pgm_sock_t*)0x1;
skb->tstamp = 0x1;
skb->data = skb->head;
skb->len = sizeof(struct pgm_header) + sizeof(struct pgm_data) + source_len;
skb->tail = (guint8*)skb->data + skb->len;
/* add PGM header */
struct pgm_header* pgmhdr = skb->head;
pgmhdr->pgm_sport = g_htons ((guint16)1000);
pgmhdr->pgm_dport = g_htons ((guint16)7500);
pgmhdr->pgm_type = PGM_ODATA;
pgmhdr->pgm_options = 0;
pgmhdr->pgm_gsi[0] = 1;
pgmhdr->pgm_gsi[1] = 2;
pgmhdr->pgm_gsi[2] = 3;
pgmhdr->pgm_gsi[3] = 4;
pgmhdr->pgm_gsi[4] = 5;
pgmhdr->pgm_gsi[5] = 6;
pgmhdr->pgm_tsdu_length = g_htons (source_len);
/* add ODATA header */
struct pgm_data* datahdr = (gpointer)(pgmhdr + 1);
datahdr->data_sqn = g_htonl ((guint32)0);
datahdr->data_trail = g_htonl ((guint32)-1);
/* add payload */
gpointer data = (gpointer)(datahdr + 1);
memcpy (data, source, source_len);
/* finally PGM checksum */
pgmhdr->pgm_checksum = 0;
pgmhdr->pgm_checksum = pgm_csum_fold (pgm_csum_partial (pgmhdr, sizeof(struct pgm_header) + sizeof(struct pgm_data) + source_len, 0));
return skb;
}
ArvGvspPacket *
arv_gvsp_packet_new_data_leader (guint16 frame_id, guint32 packet_id,
guint64 timestamp, ArvPixelFormat pixel_format,
guint32 width, guint32 height,
guint32 x_offset, guint32 y_offset,
void *buffer, size_t *buffer_size)
{
ArvGvspPacket *packet;
packet = arv_gvsp_packet_new (ARV_GVSP_CONTENT_TYPE_DATA_LEADER,
frame_id, packet_id, sizeof (ArvGvspDataLeader), buffer, buffer_size);
if (packet != NULL) {
ArvGvspDataLeader *leader;
leader = (ArvGvspDataLeader *) &packet->data;
leader->payload_type = g_htonl (0x00000001); /* ID for image data */
leader->timestamp_high = g_htonl (((guint64) timestamp >> 32));
leader->timestamp_low = g_htonl ((guint64) timestamp & 0xffffffff);
leader->pixel_format = g_htonl (pixel_format);
leader->width = g_htonl (width);
leader->height = g_htonl (height);
leader->x_offset = g_htonl (x_offset);
leader->y_offset = g_htonl (y_offset);
}
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;
}
static GByteArray *
_m2v2_pack_request_with_flags(const char *name, struct oio_url_s *url,
GByteArray *body, guint32 flags)
{
MESSAGE msg = _m2v2_build_request(name, url, body);
flags = g_htonl(flags);
metautils_message_add_field(msg, NAME_MSGKEY_FLAGS, &flags, sizeof(flags));
return message_marshall_gba_and_clean(msg);
}
/*
* Parse the address and port information in a PORT command or in the
* response to a PASV command. Return TRUE if we found an address and
* port, and supply the address and port; return FALSE if we didn't find
* them.
*
* We ignore the IP address in the reply, and use the address from which
* the request came.
*
* XXX - are there cases where they differ? What if the FTP server is
* behind a NAT box, so that the address it puts into the reply isn't
* the address at which you should contact it? Do all NAT boxes detect
* FTP PASV replies and rewrite the address? (I suspect not.)
*
* RFC 959 doesn't say much about the syntax of the 227 reply.
*
* A proposal from Dan Bernstein at
*
* http://cr.yp.to/ftp/retr.html
*
* "recommend[s] that clients use the following strategy to parse the
* response line: look for the first digit after the initial space; look
* for the fourth comma after that digit; read two (possibly negative)
* integers, separated by a comma; the TCP port number is p1*256+p2, where
* p1 is the first integer modulo 256 and p2 is the second integer modulo
* 256."
*
* wget 1.5.3 looks for a digit, although it doesn't handle negative
* integers.
*
* The FTP code in the source of the cURL library, at
*
* http://curl.haxx.se/lxr/source/lib/ftp.c
*
* says that cURL "now scans for a sequence of six comma-separated numbers
* and will take them as IP+port indicators"; it loops, doing "sscanf"s
* looking for six numbers separated by commas, stepping the start pointer
* in the scanf one character at a time - i.e., it tries rather exhaustively.
*
* An optimization would be to scan for a digit, and start there, and if
* the scanf doesn't find six values, scan for the next digit and try
* again; this will probably succeed on the first try.
*
* The cURL code also says that "found reply-strings include":
*
* "227 Entering Passive Mode (127,0,0,1,4,51)"
* "227 Data transfer will passively listen to 127,0,0,1,4,51"
* "227 Entering passive mode. 127,0,0,1,4,51"
*
* so it appears that you can't assume there are parentheses around
* the address and port number.
*/
static gboolean
parse_port_pasv(const guchar *line, int linelen, guint32 *ftp_ip, guint16 *ftp_port)
{
char *args;
char *p;
guchar c;
int i;
int ip_address[4], port[2];
gboolean ret = FALSE;
/*
* Copy the rest of the line into a null-terminated buffer.
*/
args = ep_strndup(line, linelen);
p = args;
for (;;) {
/*
* Look for a digit.
*/
while ((c = *p) != '\0' && !isdigit(c))
p++;
if (*p == '\0') {
/*
* We ran out of text without finding anything.
*/
break;
}
/*
* See if we have six numbers.
*/
i = sscanf(p, "%d,%d,%d,%d,%d,%d",
&ip_address[0], &ip_address[1], &ip_address[2], &ip_address[3],
&port[0], &port[1]);
if (i == 6) {
/*
* We have a winner!
*/
*ftp_port = ((port[0] & 0xFF)<<8) | (port[1] & 0xFF);
*ftp_ip = g_htonl((ip_address[0] << 24) | (ip_address[1] <<16) | (ip_address[2] <<8) | ip_address[3]);
ret = TRUE;
break;
}
/*
* Well, that didn't work. Skip the first number we found,
* and keep trying.
*/
while ((c = *p) != '\0' && isdigit(c))
p++;
}
return ret;
}
static t_nid
get_nid(tvbuff_t *tvb, gint offset)
{
t_nid nid ;
nid.addr = g_htonl(tvb_get_ipv4(tvb, offset));
nid.interface = tvb_get_letohs(tvb, offset + 4);
nid.proto = tvb_get_letohs(tvb, offset + 6);
return nid ;
}
static void
pack (GString *buffer)
{
guint32 content_size;
gchar content_string[sizeof(guint32)];
content_size = g_htonl(buffer->len);
memcpy(content_string, &content_size, sizeof(content_size));
g_string_prepend_len(buffer, content_string, sizeof(content_size));
}
/* 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;
}
/* pack four bytes as "guint32" into buf
* return the number of bytes packed, otherwise return -1 */
gint create_packet_dw(guint8 *buf, guint8 **cursor, guint32 dw)
{
if (*cursor <= buf + MAX_PACKET_SIZE - sizeof(guint32)) {
**(guint32 **) cursor = g_htonl(dw);
*cursor += sizeof(guint32);
return sizeof(guint32);
} else {
return -1;
}
}
static void gfire_sq_ase_query(gfire_game_server *p_server, gboolean p_full, int p_socket)
{
static const gchar query = 's';
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = g_htonl(p_server->ip);
addr.sin_port = g_htons(p_server->query_port);
sendto(p_socket, &query, sizeof(query), 0, (struct sockaddr*)&addr, sizeof(addr));
}
