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;
}
/**
* gnome_vfs_address_get_sockaddr:
* @address: A #GnomeVFSAddress
* @port: A valid port in host byte order to set in the returned sockaddr
* structure.
* @len: A pointer to an int which will contain the length of the
* return sockaddr structure.
*
* This function tanslates @address into a equivalent
* sockaddr structure. The port specified at @port will
* be set in the structure and @len will be set to the length
* of the structure.
*
*
* Return value: A newly allocated sockaddr structure the caller must free
* or %NULL if @address did not point to a valid #GnomeVFSAddress.
**/
struct sockaddr *
gnome_vfs_address_get_sockaddr (GnomeVFSAddress *address,
guint16 port,
int *len)
{
struct sockaddr *sa;
g_return_val_if_fail (address != NULL, NULL);
sa = g_memdup (address->sa, SA_SIZE (address->sa));
switch (address->sa->sa_family) {
#ifdef ENABLE_IPV6
case AF_INET6:
SIN6 (sa)->sin6_port = g_htons (port);
if (len != NULL) {
*len = SIN6_LEN;
}
break;
#endif
case AF_INET:
SIN (sa)->sin_port = g_htons (port);
if (len != NULL) {
*len = SIN_LEN;
}
break;
}
return sa;
}
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;
}
/* zwraca watcha */
static watch_t *jabber_dcc_init(int port) {
struct sockaddr_in sin;
int fd;
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
debug_error("jabber_dcc_init() socket() FAILED (%s)\n", strerror(errno));
return NULL;
}
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = g_htons(port);
while (bind(fd, (struct sockaddr *) &sin, sizeof(struct sockaddr_in))) {
debug_error("jabber_dcc_init() bind() port: %d FAILED (%s)\n", port, strerror(errno));
port++;
if (port > 65535) {
close(fd);
return NULL;
}
sin.sin_port = g_htons(port);
}
if (listen(fd, 10)) {
debug_error("jabber_dcc_init() listen() FAILED (%s)\n", strerror(errno));
close(fd);
return NULL;
}
debug_function("jabber_dcc_init() SUCCESSED fd:%d port:%d\n", fd, port);
jabber_dcc_port = port;
jabber_dcc_fd = fd;
return watch_add(&jabber_plugin, fd, WATCH_READ, jabber_dcc_handle_accept, NULL);
}
static
struct pgm_sock_t*
generate_sock (void)
{
const pgm_tsi_t tsi = { { 1, 2, 3, 4, 5, 6 }, g_htons(1000) };
struct pgm_sock_t* sock = g_new0 (struct pgm_sock_t, 1);
memcpy (&sock->tsi, &tsi, sizeof(pgm_tsi_t));
sock->is_bound = FALSE;
sock->is_destroyed = FALSE;
((struct sockaddr*)&sock->send_addr)->sa_family = AF_INET;
((struct sockaddr_in*)&sock->send_addr)->sin_addr.s_addr = inet_addr ("127.0.0.2");
((struct sockaddr*)&sock->send_gsr.gsr_group)->sa_family = AF_INET;
((struct sockaddr_in*)&sock->send_gsr.gsr_group)->sin_addr.s_addr = inet_addr ("239.192.0.1");
sock->dport = g_htons(TEST_PORT);
sock->window = g_malloc0 (sizeof(pgm_txw_t));
sock->txw_sqns = TEST_TXW_SQNS;
sock->max_tpdu = TEST_MAX_TPDU;
sock->max_tsdu = TEST_MAX_TPDU - sizeof(struct pgm_ip) - pgm_pkt_offset (FALSE, FALSE);
sock->max_tsdu_fragment = TEST_MAX_TPDU - sizeof(struct pgm_ip) - pgm_pkt_offset (TRUE, FALSE);
sock->max_apdu = MIN(TEST_TXW_SQNS, PGM_MAX_FRAGMENTS) * sock->max_tsdu_fragment;
sock->iphdr_len = sizeof(struct pgm_ip);
sock->spm_heartbeat_interval = g_malloc0 (sizeof(guint) * (2+2));
sock->spm_heartbeat_interval[0] = pgm_secs(1);
pgm_spinlock_init (&sock->txw_spinlock);
pgm_mutex_init (&sock->source_mutex);
pgm_mutex_init (&sock->timer_mutex);
pgm_rwlock_init (&sock->lock);
return sock;
}
gboolean
grid_string_to_sockaddr(const gchar *start, struct sockaddr *s, gsize *slen)
{
EXTRA_ASSERT (start != NULL);
EXTRA_ASSERT (slen != NULL);
if (!*start)
return FALSE;
gchar *addr = g_strdup (start);
STRING_STACKIFY(addr);
EXTRA_ASSERT(addr != NULL);
if (*addr == '/') { // UNIX socket
struct sockaddr_un *sun = (struct sockaddr_un*) s;
*slen = sizeof(*sun);
sun->sun_family = AF_UNIX;
g_strlcpy(sun->sun_path, addr, sizeof(sun->sun_path));
return TRUE;
}
// Find the ':' separator and fill the working buffers with each part
gchar *colon = strrchr(addr, ':');
if (!colon) return FALSE;
*(colon++) = '\0';
// Parse the port
guint16 u16port = 0;
if (!_port_parse(colon, &u16port))
return 0;
// And now, parse the address
if (addr[0] == '[') {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) s;
size_t l = strlen(addr);
*slen = sizeof(struct sockaddr_in6);
if (addr[l-1] == ']')
addr[--l] = '\0';
if (0 < inet_pton(AF_INET6, addr+1, &sin6->sin6_addr)) {
sin6->sin6_family = AF_INET6;
sin6->sin6_port = g_htons(u16port);
return 1;
}
} else {
struct sockaddr_in *sin = (struct sockaddr_in*) s;
*slen = sizeof(struct sockaddr_in);
if (0 < inet_pton(AF_INET, addr, &sin->sin_addr)) {
sin->sin_family = AF_INET;
sin->sin_port = g_htons(u16port);
return 1;
}
}
return 0;
}
gssize g_obex_header_encode(GObexHeader *header, void *buf, gsize buf_len)
{
guint8 *ptr = buf;
guint16 u16;
guint32 u32;
gunichar2 *utf16;
glong utf16_len;
g_obex_debug(G_OBEX_DEBUG_HEADER, "header 0x%02x",
G_OBEX_HDR_ENC(header->id));
if (buf_len < header->hlen)
return -1;
ptr = put_bytes(ptr, &header->id, sizeof(header->id));
switch (G_OBEX_HDR_ENC(header->id)) {
case G_OBEX_HDR_ENC_UNICODE:
utf16_len = utf8_to_utf16(&utf16, header->v.string);
if (utf16_len < 0 || (guint16) utf16_len > buf_len)
return -1;
g_assert_cmpuint(utf16_len + 3, ==, header->hlen);
u16 = g_htons(utf16_len + 3);
ptr = put_bytes(ptr, &u16, sizeof(u16));
ptr = put_bytes(ptr, utf16, utf16_len);
g_free(utf16);
break;
case G_OBEX_HDR_ENC_BYTES:
u16 = g_htons(header->hlen);
ptr = put_bytes(ptr, &u16, sizeof(u16));
if (header->extdata)
ptr = put_bytes(ptr, header->v.extdata, header->vlen);
else
ptr = put_bytes(ptr, header->v.data, header->vlen);
break;
case G_OBEX_HDR_ENC_UINT8:
*ptr = header->v.u8;
break;
case G_OBEX_HDR_ENC_UINT32:
u32 = g_htonl(header->v.u32);
ptr = put_bytes(ptr, &u32, sizeof(u32));
break;
default:
g_assert_not_reached();
}
return header->hlen;
}
static gboolean
sink_next_uint16 (SerialSink* sink, guint16 num)
{
num = g_htons (num);
return sink->sink_write (sink, (guint8*) &num, sizeof (num));
}
void
rtp_packet_set_seq(Rtp_Packet packet, guint16 seq)
{
g_return_if_fail(packet != NULL);
((Rtp_Header) packet -> data) -> seq = g_htons(seq);
}
void
register_service (int port)
{
int dnsfd;
GSource *source;
if (DNSServiceRegister (&g_sdref, 0, 0, NULL, "_xmms2._tcp", NULL, NULL,
g_htons (port), 0, NULL, dns_callback, NULL)
!= kDNSServiceErr_NoError) {
printf ("failed to register!\n");
exit (1);
}
dnsfd = DNSServiceRefSockFD (g_sdref);
if (dnsfd == -1) {
printf ("no fd!?\n");
exit (1);
}
pollfd = g_new0 (GPollFD, 1);
pollfd->fd = dnsfd;
pollfd->events = G_IO_IN | G_IO_HUP | G_IO_ERR;
source = g_source_new (&dns_ipc_func, sizeof (GSource));
g_source_add_poll (source, pollfd);
g_source_attach (source, NULL);
}
// http://doc.qt.nokia.com/4.6/datastreamformat.html
// A QString has the length in the first 4 bytes, then the string in UTF-16 encoding
// Has to be stored as big endian!
static gchar* char2qstring(const gchar* in, gsize* size)
{
glong read, written;
GError* error = NULL;
gunichar2* out = g_utf8_to_utf16(in, -1, &read, &written, &error);
if(error)
{
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_kwallet] ERROR: error converting string: %s\n", error->message);
g_error_free(error);
return NULL;
}
glong i;
for(i=0; i<written; ++i)
{
out[i] = g_htons(out[i]);
}
guint bytes = sizeof(gunichar2)*written;
guint BE_bytes = GUINT_TO_BE(bytes);
*size = sizeof(guint)+bytes;
gchar* result = g_malloc(*size);
memcpy(result, &BE_bytes, sizeof(guint));
memcpy(result+sizeof(guint), out, bytes);
return result;
}
/*
* 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 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;
}
void
test_stop_on_connect (void)
{
struct sockaddr_in address;
const gchar host_name[] = "mx.local.net";
const gchar ip_address[] = "192.168.123.123";
guint16 port;
port = g_htons(50443);
address.sin_family = AF_INET;
address.sin_port = port;
inet_pton(AF_INET, ip_address, &(address.sin_addr));
cut_assert_true(milter_server_context_connect(context,
host_name,
(struct sockaddr *)&address,
sizeof(address)));
cut_assert_equal_uint(1, n_stop_on_connect);
cut_assert_equal_string(host_name, connect_host_name);
cut_assert_equal_int(sizeof(struct sockaddr_in), connect_address_size);
cut_assert_equal_uint(1, n_stopped);
cut_assert_equal_uint(0, n_accept);
}
PRIVATE void pickle_instance(Generator *g, ObjectStoreItem *item, ObjectStore *db) {
Data *data = g->data;
objectstore_item_set_integer(item, "voice_bypass_libaudiofile", 0);
objectstore_item_set_integer(item, "voice_store_sample", data->store_sample);
if (data->filename != NULL)
objectstore_item_set_string(item, "voice_filename", data->filename);
objectstore_item_set_integer(item, "voice_channels", data->channels);
if (data->store_sample) {
int bytelength = sizeof(gint16) * data->frames * data->channels;
gint16 *buf = safe_malloc(bytelength);
int i;
objectstore_item_set_integer(item, "voice_length", data->frames * data->channels);
for (i = 0; i < (data->frames * data->channels); i++)
buf[i] = g_htons(MAX(-32768, MIN(32767, 32768 * data->sample[i])));
objectstore_item_set(item, "voice_sample",
objectstore_datum_new_binary(bytelength, (void *) buf));
free(buf);
}
}
static GstBufferListItem
set_seq_header (GstBuffer ** buffer, guint group, guint idx, guint16 * seq)
{
GST_RTP_HEADER_SEQ (GST_BUFFER_DATA (*buffer)) = g_htons (*seq);
(*seq)++;
return GST_BUFFER_LIST_SKIP_GROUP;
}
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 GByteArray *
generate_duid_from_machine_id (void)
{
GByteArray *duid;
char *contents = NULL;
GChecksum *sum;
guint8 buffer[32]; /* SHA256 digest size */
gsize sumlen = sizeof (buffer);
const guint16 duid_type = g_htons (4);
uuid_t uuid;
GRand *generator;
guint i;
gboolean success = FALSE;
/* Get the machine ID from /etc/machine-id; it's always in /etc no matter
* where our configured SYSCONFDIR is. Alternatively, it might be in
* LOCALSTATEDIR /lib/dbus/machine-id.
*/
if ( g_file_get_contents ("/etc/machine-id", &contents, NULL, NULL)
|| g_file_get_contents (LOCALSTATEDIR "/lib/dbus/machine-id", &contents, NULL, NULL)) {
contents = g_strstrip (contents);
success = machine_id_parse (contents, uuid);
if (success) {
/* Hash the machine ID so it's not leaked to the network */
sum = g_checksum_new (G_CHECKSUM_SHA256);
g_checksum_update (sum, (const guchar *) &uuid, sizeof (uuid));
g_checksum_get_digest (sum, buffer, &sumlen);
g_checksum_free (sum);
}
g_free (contents);
}
if (!success) {
nm_log_warn (LOGD_DHCP6, "Failed to read " SYSCONFDIR "/machine-id "
"or " LOCALSTATEDIR "/lib/dbus/machine-id to generate "
"DHCPv6 DUID; creating non-persistent random DUID.");
generator = g_rand_new ();
for (i = 0; i < sizeof (buffer) / sizeof (guint32); i++)
((guint32 *) buffer)[i] = g_rand_int (generator);
g_rand_free (generator);
}
/* Generate a DHCP Unique Identifier for DHCPv6 using the
* DUID-UUID method (see RFC 6355 section 4). Format is:
*
* u16: type (DUID-UUID = 4)
* u8[16]: UUID bytes
*/
duid = g_byte_array_sized_new (18);
g_byte_array_append (duid, (guint8 *) &duid_type, sizeof (duid_type));
/* Since SHA256 is 256 bits, but UUID is 128 bits, we just take the first
* 128 bits of the SHA256 as the DUID-UUID.
*/
g_byte_array_append (duid, buffer, 16);
return duid;
}
EXPORT_C
#endif
void
gst_rtp_buffer_set_seq (GstBuffer * buffer, guint16 seq)
{
GST_RTP_HEADER_SEQ (GST_BUFFER_DATA (buffer)) = g_htons (seq);
}
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;
}
ArvGvcpPacket *
arv_gvcp_packet_new_discovery_ack (size_t *packet_size)
{
ArvGvcpPacket *packet;
g_return_val_if_fail (packet_size != NULL, NULL);
*packet_size = sizeof (ArvGvcpHeader) + ARV_GVBS_DISCOVERY_DATA_SIZE ;
packet = g_malloc (*packet_size);
packet->header.packet_type = g_htons (ARV_GVCP_PACKET_TYPE_ACK);
packet->header.command = g_htons (ARV_GVCP_COMMAND_DISCOVERY_ACK);
packet->header.size = g_htons (ARV_GVBS_DISCOVERY_DATA_SIZE);
packet->header.id = g_htons (0xffff);
return packet;
}
ArvGvcpPacket *
arv_gvcp_packet_new_discovery_cmd (size_t *packet_size)
{
ArvGvcpPacket *packet;
g_return_val_if_fail (packet_size != NULL, NULL);
*packet_size = sizeof (ArvGvcpHeader);
packet = g_malloc (*packet_size);
packet->header.packet_type = g_htons (ARV_GVCP_PACKET_TYPE_BROADCAST_CMD);
packet->header.command = g_htons (ARV_GVCP_COMMAND_DISCOVERY_CMD);
packet->header.size = g_htons (0x0000);
packet->header.id = g_htons (0xffff);
return packet;
}
static GstBuffer *
gst_rtp_dtmf_src_create_next_rtp_packet (GstRTPDTMFSrc * dtmfsrc)
{
GstBuffer *buf;
GstRTPDTMFPayload *payload;
GstRTPBuffer rtpbuffer = GST_RTP_BUFFER_INIT;
buf = gst_rtp_buffer_new_allocate (sizeof (GstRTPDTMFPayload), 0, 0);
gst_rtp_buffer_map (buf, GST_MAP_READWRITE, &rtpbuffer);
gst_rtp_dtmf_prepare_rtp_headers (dtmfsrc, &rtpbuffer);
/* timestamp and duration of GstBuffer */
/* Redundant buffer have no duration ... */
if (dtmfsrc->redundancy_count > 1)
GST_BUFFER_DURATION (buf) = 0;
else
GST_BUFFER_DURATION (buf) = dtmfsrc->ptime * GST_MSECOND;
GST_BUFFER_PTS (buf) = dtmfsrc->timestamp;
payload = (GstRTPDTMFPayload *) gst_rtp_buffer_get_payload (&rtpbuffer);
/* copy payload and convert to network-byte order */
memmove (payload, dtmfsrc->payload, sizeof (GstRTPDTMFPayload));
payload->duration = g_htons (payload->duration);
if (dtmfsrc->redundancy_count <= 1 && dtmfsrc->last_packet) {
GstClockTime inter_digit_interval = MIN_INTER_DIGIT_INTERVAL;
if (inter_digit_interval % dtmfsrc->ptime != 0)
inter_digit_interval += dtmfsrc->ptime -
(MIN_INTER_DIGIT_INTERVAL % dtmfsrc->ptime);
GST_BUFFER_DURATION (buf) += inter_digit_interval * GST_MSECOND;
}
GST_LOG_OBJECT (dtmfsrc, "Creating new buffer with event %u duration "
" gst: %" GST_TIME_FORMAT " at %" GST_TIME_FORMAT "(rtp ts:%u dur:%u)",
dtmfsrc->payload->event, GST_TIME_ARGS (GST_BUFFER_DURATION (buf)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), dtmfsrc->rtp_timestamp,
dtmfsrc->payload->duration);
/* duration of DTMF payloadfor the NEXT packet */
/* not updated for redundant packets */
if (dtmfsrc->redundancy_count <= 1)
dtmfsrc->payload->duration += dtmfsrc->ptime * dtmfsrc->clock_rate / 1000;
if (GST_CLOCK_TIME_IS_VALID (dtmfsrc->timestamp))
dtmfsrc->timestamp += GST_BUFFER_DURATION (buf);
gst_rtp_buffer_unmap (&rtpbuffer);
return buf;
}
/* pack two bytes as "guint16" into buf
* return the number of bytes packed, otherwise return -1 */
gint create_packet_w(guint8 *buf, guint8 **cursor, guint16 w)
{
if (*cursor <= buf + MAX_PACKET_SIZE - sizeof(guint16)) {
**(guint16 **) cursor = g_htons(w);
*cursor += sizeof(guint16);
return sizeof(guint16);
} else {
return -1;
}
}
EXPORT_C
#endif
void
gst_rtp_buffer_set_seq (GstBuffer * buffer, guint16 seq)
{
g_return_if_fail (GST_IS_BUFFER (buffer));
g_return_if_fail (GST_BUFFER_DATA (buffer) != NULL);
GST_RTP_HEADER_SEQ (buffer) = g_htons (seq);
}
/* utility function for writing a sample to file in rtpdump -F dump format (.rtp)*/
static void rtp_write_sample(rtpdump_info_t* rtpdump_info, FILE* file)
{
guint16 length; /* length of packet, including this header (may
be smaller than plen if not whole packet recorded) */
guint16 plen; /* actual header+payload length for RTP, 0 for RTCP */
guint32 offset; /* milliseconds since the start of recording */
length = g_htons(rtpdump_info->num_samples + 8);
plen = g_htons(rtpdump_info->num_samples);
offset = g_htonl(rtpdump_info->rec_time);
if (fwrite(&length, 2, 1, file) == 0)
return;
if (fwrite(&plen, 2, 1, file) == 0)
return;
if (fwrite(&offset, 4, 1, file) == 0)
return;
if (fwrite(rtpdump_info->samples, rtpdump_info->num_samples, 1, file) == 0)
return;
}
/* utility function for writing a sample to file in rtpdump -F dump format (.rtp)*/
void rtp_write_sample(rtp_sample_t* sample, FILE* file)
{
guint16 length; /* length of packet, including this header (may
be smaller than plen if not whole packet recorded) */
guint16 plen; /* actual header+payload length for RTP, 0 for RTCP */
guint32 offset; /* milliseconds since the start of recording */
length = g_htons(sample->header.frame_length + 8);
plen = g_htons(sample->header.frame_length);
offset = g_htonl(sample->header.rec_time);
if (fwrite(&length, 2, 1, file) == 0)
return;
if (fwrite(&plen, 2, 1, file) == 0)
return;
if (fwrite(&offset, 4, 1, file) == 0)
return;
if (fwrite(sample->frame, sample->header.frame_length, 1, file) == 0)
return;
}
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));
}
static void gfire_sq_savage_query(gfire_game_server *p_server, gboolean p_full, int p_socket)
{
static guint8 query[] = { 0x9e, 0x4c, 0x23, 0x00, 0x00, 0xce, 'G', 'F', 'S', 'Q' };
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, 10, 0, (struct sockaddr*)&addr, sizeof(addr));
}
