/**
* gnome_vfs_async_create:
* @handle_return: pointer to a pointer to a #GnomeVFSHandle object.
* @text_uri: string representing the uri to create.
* @open_mode: mode to leave the file opened in after creation (or %GNOME_VFS_OPEN_MODE_NONE
* to leave the file closed after creation).
* @exclusive: whether the file should be created in "exclusive" mode:
* i.e. if this flag is nonzero, operation will fail if a file with the
* same name already exists.
* @perm: bitmap representing the permissions for the newly created file
* (Unix style).
* @priority: a value from %GNOME_VFS_PRIORITY_MIN to %GNOME_VFS_PRIORITY_MAX (normally
* should be %GNOME_VFS_PRIORITY_DEFAULT) indicating the priority to assign this job
* in allocating threads from the thread pool.
* @callback: function to be called when the operation is complete.
* @callback_data: data to pass to @callback.
*
* Create a file at @uri according to mode @open_mode, with permissions @perm (in
* the standard UNIX packed bit permissions format). When the create has been completed
* @callback will be called with the result code and @callback_data.
*/
void
gnome_vfs_async_create (GnomeVFSAsyncHandle **handle_return,
const gchar *text_uri,
GnomeVFSOpenMode open_mode,
gboolean exclusive,
guint perm,
int priority,
GnomeVFSAsyncOpenCallback callback,
gpointer callback_data)
{
GnomeVFSURI *uri;
g_return_if_fail (handle_return != NULL);
g_return_if_fail (text_uri != NULL);
g_return_if_fail (callback != NULL);
g_return_if_fail (priority >= GNOME_VFS_PRIORITY_MIN);
g_return_if_fail (priority <= GNOME_VFS_PRIORITY_MAX);
uri = gnome_vfs_uri_new (text_uri);
*handle_return = async_create (uri, open_mode, exclusive, perm,
priority, callback, callback_data);
if (uri != NULL) {
gnome_vfs_uri_unref (uri);
}
}
/**
* gnome_vfs_async_create_uri:
* @handle_return: pointer to a pointer to a #GnomeVFSHandle object.
* @uri: uri to create a file at.
* @open_mode: mode to leave the file opened in after creation (or %GNOME_VFS_OPEN_MODE_NONE
* to leave the file closed after creation).
* @exclusive: Whether the file should be created in "exclusive" mode:
* i.e. if this flag is nonzero, operation will fail if a file with the
* same name already exists.
* @perm: bitmap representing the permissions for the newly created file
* (Unix style).
* @priority: a value from %GNOME_VFS_PRIORITY_MIN to %GNOME_VFS_PRIORITY_MAX (normally
* should be %GNOME_VFS_PRIORITY_DEFAULT) indicating the priority to assign this job
* in allocating threads from the thread pool.
* @callback: function to be called when the operation is complete.
* @callback_data: data to pass to @callback.
*
* Create a file at @uri according to mode @open_mode, with permissions @perm (in
* the standard UNIX packed bit permissions format). When the create has been completed
* @callback will be called with the result code and @callback_data.
*/
void
gnome_vfs_async_create_uri (GnomeVFSAsyncHandle **handle_return,
GnomeVFSURI *uri,
GnomeVFSOpenMode open_mode,
gboolean exclusive,
guint perm,
int priority,
GnomeVFSAsyncOpenCallback callback,
gpointer callback_data)
{
g_return_if_fail (handle_return != NULL);
g_return_if_fail (uri != NULL);
g_return_if_fail (callback != NULL);
g_return_if_fail (priority >= GNOME_VFS_PRIORITY_MIN);
g_return_if_fail (priority <= GNOME_VFS_PRIORITY_MAX);
*handle_return = async_create (uri, open_mode, exclusive, perm,
priority, callback, callback_data);
}
static
bool
on_startup (void)
{
struct pgm_addrinfo_t* res = NULL;
pgm_error_t* pgm_err = NULL;
sa_family_t sa_family = AF_UNSPEC;
/* parse network parameter into PGM socket address structure */
if (!pgm_getaddrinfo (network, NULL, &res, &pgm_err)) {
fprintf (stderr, "Parsing network parameter: %s\n", pgm_err->message);
goto err_abort;
}
sa_family = res->ai_send_addrs[0].gsr_group.ss_family;
puts ("Create PGM socket.");
if (udp_encap_port) {
if (!pgm_socket (&sock, sa_family, SOCK_SEQPACKET, IPPROTO_UDP, &pgm_err)) {
fprintf (stderr, "Creating PGM/UDP socket: %s\n", pgm_err->message);
goto err_abort;
}
pgm_setsockopt (sock, IPPROTO_PGM, PGM_UDP_ENCAP_UCAST_PORT, &udp_encap_port, sizeof(udp_encap_port));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_UDP_ENCAP_MCAST_PORT, &udp_encap_port, sizeof(udp_encap_port));
} else {
if (!pgm_socket (&sock, sa_family, SOCK_SEQPACKET, IPPROTO_PGM, &pgm_err)) {
fprintf (stderr, "Creating PGM/IP socket: %s\n", pgm_err->message);
goto err_abort;
}
}
/* Use RFC 2113 tagging for PGM Router Assist */
const int no_router_assist = 0;
pgm_setsockopt (sock, IPPROTO_PGM, PGM_IP_ROUTER_ALERT, &no_router_assist, sizeof(no_router_assist));
pgm_drop_superuser();
/* set PGM parameters */
const int recv_only = 1,
passive = 0,
peer_expiry = pgm_secs (300),
spmr_expiry = pgm_msecs (250),
nak_bo_ivl = pgm_msecs (50),
nak_rpt_ivl = pgm_secs (2),
nak_rdata_ivl = pgm_secs (2),
nak_data_retries = 50,
nak_ncf_retries = 50;
pgm_setsockopt (sock, IPPROTO_PGM, PGM_RECV_ONLY, &recv_only, sizeof(recv_only));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_PASSIVE, &passive, sizeof(passive));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_MTU, &max_tpdu, sizeof(max_tpdu));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_RXW_SQNS, &sqns, sizeof(sqns));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_PEER_EXPIRY, &peer_expiry, sizeof(peer_expiry));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_SPMR_EXPIRY, &spmr_expiry, sizeof(spmr_expiry));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NAK_BO_IVL, &nak_bo_ivl, sizeof(nak_bo_ivl));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NAK_RPT_IVL, &nak_rpt_ivl, sizeof(nak_rpt_ivl));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NAK_RDATA_IVL, &nak_rdata_ivl, sizeof(nak_rdata_ivl));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NAK_DATA_RETRIES, &nak_data_retries, sizeof(nak_data_retries));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NAK_NCF_RETRIES, &nak_ncf_retries, sizeof(nak_ncf_retries));
if (use_fec) {
struct pgm_fecinfo_t fecinfo;
fecinfo.block_size = rs_n;
fecinfo.proactive_packets = 0;
fecinfo.group_size = rs_k;
fecinfo.ondemand_parity_enabled = TRUE;
fecinfo.var_pktlen_enabled = TRUE;
pgm_setsockopt (sock, IPPROTO_PGM, PGM_USE_FEC, &fecinfo, sizeof(fecinfo));
}
/* create global session identifier */
struct pgm_sockaddr_t addr;
memset (&addr, 0, sizeof(addr));
addr.sa_port = port ? port : DEFAULT_DATA_DESTINATION_PORT;
addr.sa_addr.sport = DEFAULT_DATA_SOURCE_PORT;
if (!pgm_gsi_create_from_hostname (&addr.sa_addr.gsi, &pgm_err)) {
fprintf (stderr, "Creating GSI: %s\n", pgm_err->message);
goto err_abort;
}
/* assign socket to specified address */
struct pgm_interface_req_t if_req;
memset (&if_req, 0, sizeof(if_req));
if_req.ir_interface = res->ai_recv_addrs[0].gsr_interface;
if_req.ir_scope_id = 0;
if (AF_INET6 == sa_family) {
struct sockaddr_in6 sa6;
memcpy (&sa6, &res->ai_recv_addrs[0].gsr_group, sizeof(sa6));
if_req.ir_scope_id = sa6.sin6_scope_id;
}
if (!pgm_bind3 (sock,
&addr, sizeof(addr),
&if_req, sizeof(if_req), /* tx interface */
&if_req, sizeof(if_req), /* rx interface */
&pgm_err))
{
fprintf (stderr, "Binding PGM socket: %s\n", pgm_err->message);
goto err_abort;
}
/* join IP multicast groups */
for (unsigned i = 0; i < res->ai_recv_addrs_len; i++)
pgm_setsockopt (sock, IPPROTO_PGM, PGM_JOIN_GROUP, &res->ai_recv_addrs[i], sizeof(struct group_req));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_SEND_GROUP, &res->ai_send_addrs[0], sizeof(struct group_req));
pgm_freeaddrinfo (res);
/* set IP parameters */
const int nonblocking = 1,
multicast_loop = use_multicast_loop ? 1 : 0,
multicast_hops = 16,
dscp = 0x2e << 2; /* Expedited Forwarding PHB for network elements, no ECN. */
pgm_setsockopt (sock, IPPROTO_PGM, PGM_MULTICAST_LOOP, &multicast_loop, sizeof(multicast_loop));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_MULTICAST_HOPS, &multicast_hops, sizeof(multicast_hops));
if (AF_INET6 != sa_family)
pgm_setsockopt (sock, IPPROTO_PGM, PGM_TOS, &dscp, sizeof(dscp));
pgm_setsockopt (sock, IPPROTO_PGM, PGM_NOBLOCK, &nonblocking, sizeof(nonblocking));
if (!pgm_connect (sock, &pgm_err)) {
fprintf (stderr, "Connecting PGM socket: %s\n", pgm_err->message);
goto err_abort;
}
/* wrap bound socket in asynchronous queue */
if (0 != async_create (&async, sock)) {
fprintf (stderr, "Creating asynchronous queue failed: %s\n", strerror(errno));
goto err_abort;
}
puts ("Startup complete.");
return TRUE;
err_abort:
if (NULL != sock) {
pgm_close (sock, FALSE);
sock = NULL;
}
if (NULL != res) {
pgm_freeaddrinfo (res);
res = NULL;
}
if (NULL != pgm_err) {
pgm_error_free (pgm_err);
pgm_err = NULL;
}
return FALSE;
}
