zmq::pgm_socket_t::~pgm_socket_t ()
{
if (pgm_msgv)
free (pgm_msgv);
if (transport)
pgm_transport_destroy (transport, TRUE);
}
void zmq::pgm_socket_t::close_transport (void)
{
// g_transport has to be valid.
assert (g_transport);
pgm_transport_destroy (g_transport, TRUE);
g_transport = NULL;
}
void zmq::pgm_socket_t::close_transport ()
{
// transport has to be valid.
zmq_assert (transport);
pgm_transport_destroy (transport, TRUE);
transport = NULL;
}
int
main (
int argc,
char* argv[]
)
{
int e;
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("syncrecv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:lh")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
case 'h':
case '?': usage (binary_name);
}
}
g_quit = FALSE;
#ifdef G_OS_UNIX
e = pipe (g_quit_pipe);
#else
e = _pipe (g_quit_pipe, 4096, _O_BINARY | _O_NOINHERIT);
#endif
g_assert (0 == e);
/* setup signal handlers */
signal(SIGSEGV, on_sigsegv);
signal(SIGINT, on_signal);
signal(SIGTERM, on_signal);
#ifdef SIGHUP
signal(SIGHUP, SIG_IGN);
#endif
if (!on_startup()) {
g_error ("startup failed");
exit(1);
}
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
struct timeval tv;
int timeout;
int n_fds = 2;
struct pollfd fds[ 1 + n_fds ];
char buffer[4096];
gsize len;
pgm_tsi_t from;
const int status = pgm_recvfrom (g_transport,
buffer,
sizeof(buffer),
0,
&len,
&from,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_data (buffer, len, &from);
break;
case PGM_IO_STATUS_TIMER_PENDING:
pgm_transport_get_timer_pending (g_transport, &tv);
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
pgm_transport_get_rate_remaining (g_transport, &tv);
case PGM_IO_STATUS_WOULD_BLOCK:
/* poll for next event */
block:
timeout = PGM_IO_STATUS_WOULD_BLOCK == status ? -1 : ((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
memset (fds, 0, sizeof(fds));
fds[0].fd = g_quit_pipe[0];
fds[0].events = POLLIN;
pgm_transport_poll_info (g_transport, &fds[1], &n_fds, POLLIN);
poll (fds, 1 + n_fds, timeout /* ms */);
break;
default:
if (pgm_err) {
g_warning ("%s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!g_quit);
g_message ("message loop terminated, cleaning up.");
/* cleanup */
close (g_quit_pipe[0]);
close (g_quit_pipe[1]);
if (g_transport) {
g_message ("destroying transport.");
pgm_transport_destroy (g_transport, TRUE);
g_transport = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
static gboolean
on_startup (void)
{
struct pgm_transport_info_t* res = NULL;
pgm_error_t* pgm_err = NULL;
g_message ("startup.");
g_message ("create transport.");
/* parse network parameter into transport address structure */
char network[1024];
sprintf (network, "%s", g_network);
if (!pgm_if_get_transport_info (network, NULL, &res, &pgm_err)) {
g_error ("parsing network parameter: %s", pgm_err->message);
pgm_error_free (pgm_err);
return FALSE;
}
/* create global session identifier */
if (!pgm_gsi_create_from_hostname (&res->ti_gsi, &pgm_err)) {
g_error ("creating GSI: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_if_free_transport_info (res);
return FALSE;
}
if (g_udp_encap_port) {
res->ti_udp_encap_ucast_port = g_udp_encap_port;
res->ti_udp_encap_mcast_port = g_udp_encap_port;
}
if (g_port)
res->ti_dport = g_port;
if (!pgm_transport_create (&g_transport, res, &pgm_err)) {
g_error ("creating transport: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_if_free_transport_info (res);
return FALSE;
}
pgm_if_free_transport_info (res);
/* set PGM parameters */
pgm_transport_set_nonblocking (g_transport, TRUE);
pgm_transport_set_recv_only (g_transport, TRUE, FALSE);
pgm_transport_set_max_tpdu (g_transport, g_max_tpdu);
pgm_transport_set_rxw_sqns (g_transport, g_sqns);
pgm_transport_set_hops (g_transport, 16);
pgm_transport_set_peer_expiry (g_transport, pgm_secs(300));
pgm_transport_set_spmr_expiry (g_transport, pgm_msecs(250));
pgm_transport_set_nak_bo_ivl (g_transport, pgm_msecs(50));
pgm_transport_set_nak_rpt_ivl (g_transport, pgm_secs(2));
pgm_transport_set_nak_rdata_ivl (g_transport, pgm_secs(2));
pgm_transport_set_nak_data_retries (g_transport, 50);
pgm_transport_set_nak_ncf_retries (g_transport, 50);
/* assign transport to specified address */
if (!pgm_transport_bind (g_transport, &pgm_err)) {
g_error ("binding transport: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_transport_destroy (g_transport, FALSE);
g_transport = NULL;
return FALSE;
}
g_message ("startup complete.");
return TRUE;
}
int
main (
int argc,
char* argv[]
)
{
pgm_transport_list = NULL;
g_message ("pgmrecv");
#ifdef CONFIG_WITH_HTTP
gboolean enable_http = FALSE;
#endif
#ifdef CONFIG_WITH_SNMP
gboolean enable_snmpx = FALSE;
#endif
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "a:s:n:p:lh"
#ifdef CONFIG_WITH_HTTP
"t"
#endif
#ifdef CONFIG_WITH_SNMP
"x"
#endif
)) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 'a': g_source = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
#ifdef CONFIG_WITH_HTTP
case 't': enable_http = TRUE; break;
#endif
#ifdef CONFIG_WITH_SNMP
case 'x': enable_snmpx = TRUE; break;
#endif
case 'h':
case '?': usage (binary_name);
}
}
log_init();
pgm_init();
#ifdef CONFIG_WITH_HTTP
if (enable_http)
pgm_http_init(PGM_HTTP_DEFAULT_SERVER_PORT);
#endif
#ifdef CONFIG_WITH_SNMP
if (enable_snmpx)
pgm_snmp_init();
#endif
g_loop = g_main_loop_new (NULL, FALSE);
/* setup signal handlers */
signal(SIGSEGV, on_sigsegv);
pgm_signal_install(SIGINT, on_signal);
pgm_signal_install(SIGTERM, on_signal);
pgm_signal_install(SIGHUP, SIG_IGN);
/* delayed startup */
g_message ("scheduling startup.");
g_timeout_add (0, (GSourceFunc)on_startup, NULL);
/* dispatch loop */
g_message ("entering main event loop ... ");
g_main_loop_run (g_loop);
g_message ("event loop terminated, cleaning up.");
/* cleanup */
g_quit = TRUE;
g_thread_join (g_thread);
g_main_loop_unref(g_loop);
g_loop = NULL;
if (g_transport) {
g_message ("destroying transport.");
pgm_transport_destroy (g_transport, TRUE);
g_transport = NULL;
}
#ifdef CONFIG_WITH_HTTP
if (enable_http)
pgm_http_shutdown();
#endif
#ifdef CONFIG_WITH_SNMP
if (enable_snmpx)
pgm_snmp_shutdown();
#endif
g_message ("finished.");
return 0;
}
