int zmq_ctx_term (void *ctx_)
{
if (!ctx_ || !((zmq::ctx_t*) ctx_)->check_tag ()) {
errno = EFAULT;
return -1;
}
int rc = ((zmq::ctx_t*) ctx_)->terminate ();
int en = errno;
// Shut down only if termination was not interrupted by a signal.
if (!rc || en != EINTR) {
#ifdef ZMQ_HAVE_WINDOWS
// On Windows, uninitialise socket layer.
rc = WSACleanup ();
wsa_assert (rc != SOCKET_ERROR);
#endif
#if defined ZMQ_HAVE_OPENPGM
// Shut down the OpenPGM library.
if (pgm_shutdown () != TRUE)
zmq_assert (false);
#endif
}
errno = en;
return rc;
}
int zmq_ctx_destroy (void *ctx_)
{
if (!ctx_ || !((zmq::ctx_t*) ctx_)->check_tag ()) {
errno = EFAULT;
return -1;
}
int rc = ((zmq::ctx_t*) ctx_)->terminate ();
int en = errno;
#ifdef ZMQ_HAVE_WINDOWS
// On Windows, uninitialise socket layer.
rc = WSACleanup ();
wsa_assert (rc != SOCKET_ERROR);
#endif
#if defined ZMQ_HAVE_OPENPGM
// Shut down the OpenPGM library.
if (pgm_shutdown () != TRUE)
zmq_assert (false);
#endif
errno = en;
return rc;
}
int zmq_term (void *dispatcher_)
{
int rc = ((zmq::dispatcher_t*) dispatcher_)->term ();
int en = errno;
#if defined ZMQ_HAVE_OPENPGM
// Shut down the OpenPGM library.
if (pgm_shutdown () != TRUE)
zmq_assert (false);
#endif
errno = en;
return rc;
}
void zmq::shutdown_network ()
{
#ifdef ZMQ_HAVE_WINDOWS
// On Windows, uninitialise socket layer.
int rc = WSACleanup ();
wsa_assert (rc != SOCKET_ERROR);
#endif
#if defined ZMQ_HAVE_OPENPGM
// Shut down the OpenPGM library.
if (pgm_shutdown () != TRUE)
zmq_assert (false);
#endif
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
pgm_sock_t* sock = NULL;
const char* network = argv[1];
int udp_encap_port = 7510;
int xxx = 0;
char buf[4196];
memset(buf, 0, 4196);
sock = create_sock(network, udp_encap_port);
int p_status = pthread_create (&nak_thread, NULL, &nak_routine, sock);
if ((sock != NULL) && (p_status == 0))
{
do {
sprintf(buf, "%d", xxx);
const int status = pgm_send (sock, buf, 4196, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
xxx ++;
usleep(10*1000);
} while(1);
}
/* cleanup */
if (sock) {
pgm_close (sock, TRUE);
sock = NULL;
}
pgm_shutdown();
return EXIT_SUCCESS;
}
int zmq_term (void *ctx_)
{
if (!ctx_) {
errno = EFAULT;
return -1;
}
int rc = ((zmq::ctx_t*) ctx_)->terminate ();
int en = errno;
#if defined ZMQ_HAVE_OPENPGM
// Shut down the OpenPGM library.
if (pgm_shutdown () != TRUE)
zmq_assert (false);
#endif
errno = en;
return rc;
}
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;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("enonblocksyncrecvmsgv");
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);
}
}
/* 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");
return EXIT_FAILURE;
}
/* incoming message buffer, iov_len must be less than SC_IOV_MAX */
const long iov_len = 8;
const long ev_len = 1;
g_message ("Using iov_len %li ev_len %li", iov_len, ev_len);
struct pgm_msgv_t msgv[iov_len];
struct epoll_event events[ev_len]; /* wait for maximum 1 event */
/* epoll file descriptor */
const int efd = epoll_create (IP_MAX_MEMBERSHIPS);
if (efd < 0) {
g_error ("epoll_create failed errno %i: \"%s\"", errno, strerror(errno));
return EXIT_FAILURE;
}
const int retval = pgm_epoll_ctl (g_sock, efd, EPOLL_CTL_ADD, EPOLLIN);
if (retval < 0) {
g_error ("pgm_epoll_ctl failed.");
return EXIT_FAILURE;
}
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
struct timeval tv;
int timeout;
size_t len;
const int status = pgm_recvmsgv (g_sock,
msgv,
iov_len,
0,
&len,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_msgv (msgv, len);
break;
case PGM_IO_STATUS_TIMER_PENDING:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (g_sock, IPPROTO_PGM, PGM_TIME_REMAIN, &tv, &optlen);
}
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (g_sock, IPPROTO_PGM, PGM_RATE_REMAIN, &tv, &optlen);
}
/* fall through */
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));
epoll_wait (efd, events, G_N_ELEMENTS(events), 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 (efd);
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
int ncmds, i;
const char *tmp;
pgm_error_t *pgm_err = NULL;
/* FIXME */
signal(SIGPIPE, SIG_IGN);
setup_signal_handlers();
cmds = table_new(cmpstr, hashmurmur2, NULL, NULL);
ncmds = sizeof commands / sizeof (struct cmd);
for (i = 0; i < ncmds; ++i) {
struct cmd *cmd = commands + i;
table_insert(cmds, cmd->name, cmd);
}
if (argc != 2 && argc != 3)
usage();
else if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
usage();
else if (argc == 3 && strcmp(argv[1], "-f"))
usage();
if (argc == 2 && daemon(1, 0) == -1)
fprintf(stderr, "Error daemonizing: %s\n", strerror(errno));
/* FIXME */
if (init_logger("/var/log/xcb/xcb-dp2.log", __LOG_DEBUG) == -1) {
fprintf(stderr, "Error initializing logger\n");
exit(1);
}
cfg_path = argc == 2 ? argv[1] : argv[2];
if ((cfg = config_load(cfg_path)) == NULL)
exit(1);
if ((tmp = variable_retrieve(cfg, "general", "log_level"))) {
if (!strcasecmp(tmp, "info"))
set_logger_level(__LOG_INFO);
else if (!strcasecmp(tmp, "notice"))
set_logger_level(__LOG_NOTICE);
else if (!strcasecmp(tmp, "warning"))
set_logger_level(__LOG_WARNING);
}
/* FIXME */
if (addms)
times = table_new(cmpstr, hashmurmur2, kfree, vfree);
clients_to_close = dlist_new(NULL, NULL);
clients = dlist_new(NULL, NULL);
monitors = dlist_new(NULL, NULL);
tp = thrpool_new(16, 512, 200, NULL);
if (!pgm_init(&pgm_err)) {
xcb_log(XCB_LOG_ERROR, "Error starting PGM engine: %s", pgm_err->message);
pgm_error_free(pgm_err);
goto err;
}
/* FIXME */
if (NEW(pgm_send_cfg) == NULL) {
xcb_log(XCB_LOG_ERROR, "Error allocating memory for PGM cfg");
goto err;
}
pgm_send_cfg->network = NULL;
pgm_send_cfg->port = 0;
init_pgm_send_cfg(pgm_send_cfg);
if (pgm_send_cfg->network == NULL) {
xcb_log(XCB_LOG_ERROR, "PGM network can't be NULL");
goto err;
}
if (pgm_send_cfg->port == 0) {
xcb_log(XCB_LOG_ERROR, "PGM port can't be zero");
goto err;
}
if ((pgm_sender = pgmsock_create(pgm_send_cfg->network, pgm_send_cfg->port, PGMSOCK_SENDER)) == NULL)
goto err;
/* FIXME */
if ((el = create_event_loop(1024 + 1000)) == NULL) {
xcb_log(XCB_LOG_ERROR, "Error creating event loop");
goto err;
}
create_time_event(el, 1, server_cron, NULL, NULL);
if ((tmp = variable_retrieve(cfg, "general", "udp_port")) && strcmp(tmp, "")) {
if ((udpsock = net_udp_server(NULL, atoi(tmp), neterr, sizeof neterr)) == -1) {
xcb_log(XCB_LOG_ERROR, "Opening port '%s': %s", tmp, neterr);
goto err;
}
if (net_nonblock(udpsock, neterr, sizeof neterr) == -1) {
xcb_log(XCB_LOG_ERROR, "Setting port '%s' nonblocking: %s", tmp, neterr);
goto err;
}
}
if ((tmp = variable_retrieve(cfg, "general", "tcp_port")) && strcmp(tmp, ""))
if ((tcpsock = net_tcp_server(NULL, atoi(tmp), neterr, sizeof neterr)) == -1) {
xcb_log(XCB_LOG_ERROR, "Opening port '%s': %s", tmp, neterr);
goto err;
}
if (udpsock > 0 && create_file_event(el, udpsock, EVENT_READABLE, read_quote, NULL) == -1) {
xcb_log(XCB_LOG_ERROR, "Unrecoverable error creating udpsock '%d' file event", udpsock);
goto err;
}
if (tcpsock > 0 && create_file_event(el, tcpsock, EVENT_READABLE, tcp_accept_handler, NULL) == -1) {
xcb_log(XCB_LOG_ERROR, "Unrecoverable error creating tcpsock '%d' file event", tcpsock);
goto err;
}
xcb_log(XCB_LOG_NOTICE, "Server dispatcher started");
start_event_loop(el, ALL_EVENTS);
delete_event_loop(el);
pgm_shutdown();
return 0;
err:
close_logger();
exit(1);
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
#if !defined(_WIN32)
puts ("プリン プリン");
#else
/* Windows consoles have incredibly limited Unicode support */
puts ("purin purin");
#endif
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
int c;
while ((c = getopt (argc, argv, "s:n:p:cf:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'c': use_pgmcc = TRUE; break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?': usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminateEvent = WSACreateEvent();
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* dispatch loop */
#ifndef _WIN32
int fds;
fd_set readfds;
#else
SOCKET recv_sock, pending_sock;
DWORD cEvents = PGM_RECV_SOCKET_READ_COUNT + 1;
WSAEVENT waitEvents[ PGM_RECV_SOCKET_READ_COUNT + 1 ];
socklen_t socklen = sizeof (SOCKET);
waitEvents[0] = terminateEvent;
waitEvents[1] = WSACreateEvent();
waitEvents[2] = WSACreateEvent();
assert (2 == PGM_RECV_SOCKET_READ_COUNT);
pgm_getsockopt (sock, IPPROTO_PGM, PGM_RECV_SOCK, &recv_sock, &socklen);
WSAEventSelect (recv_sock, waitEvents[1], FD_READ);
pgm_getsockopt (sock, IPPROTO_PGM, PGM_PENDING_SOCK, &pending_sock, &socklen);
WSAEventSelect (pending_sock, waitEvents[2], FD_READ);
#endif /* !_WIN32 */
puts ("Entering PGM message loop ... ");
do {
struct timeval tv;
#ifdef _WIN32
DWORD dwTimeout, dwEvents;
#endif
char buffer[4096];
size_t len;
struct pgm_sockaddr_t from;
socklen_t fromlen = sizeof (from);
const int status = pgm_recvfrom (sock,
buffer,
sizeof(buffer),
0,
&len,
&from,
&fromlen,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_data (buffer, len, &from);
break;
case PGM_IO_STATUS_TIMER_PENDING:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (sock, IPPROTO_PGM, PGM_TIME_REMAIN, &tv, &optlen);
}
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (sock, IPPROTO_PGM, PGM_RATE_REMAIN, &tv, &optlen);
}
case PGM_IO_STATUS_WOULD_BLOCK:
/* select for next event */
block:
#ifndef _WIN32
fds = terminate_pipe[0] + 1;
FD_ZERO(&readfds);
FD_SET(terminate_pipe[0], &readfds);
pgm_select_info (sock, &readfds, NULL, &fds);
fds = select (fds, &readfds, NULL, NULL, PGM_IO_STATUS_WOULD_BLOCK == status ? NULL : &tv);
#else
dwTimeout = PGM_IO_STATUS_WOULD_BLOCK == status ? WSA_INFINITE : (DWORD)((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
dwEvents = WSAWaitForMultipleEvents (cEvents, waitEvents, FALSE, dwTimeout, FALSE);
switch (dwEvents) {
case WSA_WAIT_EVENT_0+1: WSAResetEvent (waitEvents[1]); break;
case WSA_WAIT_EVENT_0+2: WSAResetEvent (waitEvents[2]); break;
default: break;
}
#endif /* !_WIN32 */
break;
default:
if (pgm_err) {
fprintf (stderr, "%s\n", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!is_terminated);
puts ("Message loop terminated, cleaning up.");
/* cleanup */
#ifndef _WIN32
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WSACloseEvent (waitEvents[0]);
WSACloseEvent (waitEvents[1]);
WSACloseEvent (waitEvents[2]);
#endif /* !_WIN32 */
if (sock) {
puts ("Destroying PGM socket.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown ();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* err = NULL;
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init ();
g_message ("app");
if (!pgm_init (&err)) {
g_error ("Unable to start PGM engine: %s", (err && err->message) ? err->message : "(null)");
pgm_error_free (err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
int c;
while ((c = getopt (argc, argv, "s:n:h")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
g_loop = g_main_loop_new (NULL, FALSE);
/* setup signal handlers */
#ifndef _WIN32
signal (SIGSEGV, on_sigsegv);
signal (SIGHUP, SIG_IGN);
pgm_signal_install (SIGINT, on_signal, g_loop);
pgm_signal_install (SIGTERM, on_signal, g_loop);
#else
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
/* 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_main_loop_unref(g_loop);
g_loop = NULL;
if (g_sessions) {
g_message ("destroying sessions.");
g_hash_table_foreach_remove (g_sessions, (GHRFunc)destroy_session, NULL);
g_hash_table_unref (g_sessions);
g_sessions = NULL;
}
if (g_stdin_channel) {
puts ("unbinding stdin.");
g_io_channel_unref (g_stdin_channel);
g_stdin_channel = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown();
g_message ("finished.");
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
#ifndef _WIN32
puts ("いちごのショートケーキ");
#else
puts ("ichigo no shōtokēki");
#endif
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
int c;
while ((c = getopt (argc, argv, "s:n:p:f:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?': usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminateEvent = WSACreateEvent ();
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* dispatch loop */
#ifndef _WIN32
int fds, read_fd = async_get_socket (async);
fd_set readfds;
#else
DWORD cEvents = 2;
WSAEVENT waitEvents[ 2 ];
DWORD dwEvents;
waitEvents[0] = terminateEvent;
waitEvents[1] = async_get_event (async);
#endif /* !_WIN32 */
puts ("Entering PGM message loop ... ");
do {
char buffer[4096];
struct pgm_sockaddr_t from;
socklen_t fromlen = sizeof (from);
const ssize_t len = async_recvfrom (async,
buffer,
sizeof(buffer),
&from,
&fromlen);
if (len >= 0) {
on_data (buffer, len, &from);
} else {
#ifndef _WIN32
fds = MAX(terminate_pipe[0], read_fd) + 1;
FD_ZERO(&readfds);
FD_SET(terminate_pipe[0], &readfds);
FD_SET(read_fd, &readfds);
fds = select (fds, &readfds, NULL, NULL, NULL);
#else
dwEvents = WSAWaitForMultipleEvents (cEvents, waitEvents, FALSE, WSA_INFINITE, FALSE);
switch (dwEvents) {
case WSA_WAIT_EVENT_0+1: WSAResetEvent (waitEvents[1]); break;
default: break;
}
#endif /* _WIN32 */
}
} while (!is_terminated);
puts ("Message loop terminated, cleaning up.");
/* cleanup */
#ifndef _WIN32
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WSACloseEvent (terminateEvent);
#endif /* !_WIN32 */
if (async) {
puts ("Destroying asynchronous queue.");
async_destroy (async);
async = NULL;
}
if (sock) {
puts ("Closing PGM socket.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown ();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init();
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:r:f:K:N:lih")) != -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 'r':
g_max_rte = atoi (optarg);
break;
case 'f':
g_fec = TRUE;
break;
case 'K':
g_k = atoi (optarg);
break;
case 'N':
g_n = atoi (optarg);
break;
case 'l':
g_multicast_loop = TRUE;
break;
case 'i':
pgm_if_print_all();
pgm_messages_shutdown();
return EXIT_SUCCESS;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
if (g_fec && ( !g_k || !g_n )) {
pgm_messages_shutdown();
g_error ("Invalid Reed-Solomon parameters RS(%d, %d).", g_n, g_k);
usage (binary_name);
}
/* setup signal handlers */
signal (SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
if (create_pgm_socket())
{
while (optind < argc) {
const int status = pgm_send (g_sock, argv[optind], strlen(argv[optind]) + 1, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
g_warning ("pgm_send failed.");
}
optind++;
}
}
/* cleanup */
if (g_sock) {
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
pgm_shutdown();
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("blocksyncrecv");
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);
}
}
/* setup signal handlers */
signal(SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal(SIGHUP, SIG_IGN);
#endif
#ifdef G_OS_UNIX
signal(SIGINT, on_signal);
signal(SIGTERM, on_signal);
#else
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif
on_startup();
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
char buffer[4096];
size_t len;
struct pgm_sockaddr_t from;
socklen_t fromlen = sizeof(from);
const int status = pgm_recvfrom (g_sock,
buffer,
sizeof(buffer),
0,
&len,
&from,
&fromlen,
&pgm_err);
if (PGM_IO_STATUS_NORMAL == status)
on_data (buffer, len, &from);
else {
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 */
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", 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:r:f:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'r': max_rte = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?':
usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
if (create_sock())
{
while (optind < argc) {
const int status = pgm_send (sock, argv[optind], strlen (argv[optind]) + 1, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
optind++;
}
}
/* cleanup */
if (sock) {
pgm_close (sock, TRUE);
sock = NULL;
}
pgm_shutdown();
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
#ifdef CONFIG_WITH_HTTP
gboolean enable_http = FALSE;
#endif
#ifdef CONFIG_WITH_SNMP
gboolean enable_snmpx = FALSE;
#endif
setlocale (LC_ALL, "");
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init ();
g_message ("pgmrecv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", (pgm_err && pgm_err->message) ? pgm_err->message : "(null)");
pgm_error_free (pgm_err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
g_thread_init (NULL);
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
static struct option long_options[] = {
{ "network", required_argument, NULL, 'n' },
{ "service", required_argument, NULL, 's' },
{ "port", required_argument, NULL, 'p' },
{ "enable-loop", no_argument, NULL, 'l' },
#ifdef CONFIG_WITH_HTTP
{ "enable-http", no_argument, NULL, 'H' },
#endif
#ifdef CONFIG_WITH_SNMP
{ "enable-snmp", no_argument, NULL, 'S' },
#endif
{ "list", no_argument, NULL, 'i' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int c;
while ((c = getopt_long (argc, argv, "a:s:n:p:lih"
#ifdef CONFIG_WITH_HTTP
"H"
#endif
#ifdef CONFIG_WITH_SNMP
"S"
#endif
, long_options, NULL)) != -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 'H': enable_http = TRUE; break;
#endif
#ifdef CONFIG_WITH_SNMP
case 'S': enable_snmpx = TRUE; break;
#endif
case 'i':
pgm_if_print_all();
pgm_messages_shutdown();
return EXIT_SUCCESS;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
#ifdef CONFIG_WITH_HTTP
if (enable_http) {
if (!pgm_http_init (PGM_HTTP_DEFAULT_SERVER_PORT, &pgm_err)) {
g_error ("Unable to start HTTP interface: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_shutdown();
pgm_messages_shutdown();
return EXIT_FAILURE;
}
}
#endif
#ifdef CONFIG_WITH_SNMP
if (enable_snmpx) {
if (!pgm_snmp_init (&pgm_err)) {
g_error ("Unable to start SNMP interface: %s", pgm_err->message);
pgm_error_free (pgm_err);
#ifdef CONFIG_WITH_HTTP
if (enable_http)
pgm_http_shutdown ();
#endif
pgm_shutdown ();
pgm_messages_shutdown();
return EXIT_FAILURE;
}
}
#endif
g_loop = g_main_loop_new (NULL, FALSE);
g_quit = FALSE;
/* setup signal handlers */
signal (SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifdef G_OS_UNIX
const int e = pipe (g_quit_pipe);
g_assert (0 == e);
pgm_signal_install (SIGINT, on_signal, g_loop);
pgm_signal_install (SIGTERM, on_signal, g_loop);
#else
g_quit_event = CreateEvent (NULL, TRUE, FALSE, TEXT("QuitEvent"));
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif
/* 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;
#ifdef G_OS_UNIX
const char one = '1';
const size_t writelen = write (g_quit_pipe[1], &one, sizeof(one));
g_assert (sizeof(one) == writelen);
g_thread_join (g_thread);
close (g_quit_pipe[0]);
close (g_quit_pipe[1]);
#else
WSASetEvent (g_quit_event);
g_thread_join (g_thread);
WSACloseEvent (g_quit_event);
#endif
g_main_loop_unref (g_loop);
g_loop = NULL;
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = 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 ("PGM engine shutdown.");
pgm_shutdown();
g_message ("finished.");
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
#ifndef _WIN32
puts ("プリン プリン");
#else
_putws (L"プリン プリン");
#endif
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", 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:f:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?': usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminate_event = CreateEvent (NULL, TRUE, FALSE, TEXT("TerminateEvent"));
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* dispatch loop */
#ifndef _WIN32
int fds;
fd_set readfds;
#else
int n_handles = 3, recv_sock, pending_sock;
HANDLE waitHandles[ 3 ];
DWORD dwTimeout, dwEvents;
WSAEVENT recvEvent, pendingEvent;
recvEvent = WSACreateEvent ();
pgm_getsockopt (sock, PGM_RECV_SOCK, &recv_sock, sizeof(recv_sock));
WSAEventSelect (recv_sock, recvEvent, FD_READ);
pendingEvent = WSACreateEvent ();
pgm_getsockopt (sock, PGM_PENDING_SOCK, &pending_sock, sizeof(pending_sock));
WSAEventSelect (pending_sock, pendingEvent, FD_READ);
waitHandles[0] = terminate_event;
waitHandles[1] = recvEvent;
waitHandles[2] = pendingEvent;
#endif /* !_WIN32 */
puts ("Entering PGM message loop ... ");
do {
struct timeval tv;
char buffer[4096];
size_t len;
pgm_tsi_t from;
const int status = pgm_recvfrom (sock,
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_getsockopt (sock, PGM_TIME_REMAIN, &tv, sizeof(tv));
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
pgm_getsockopt (sock, PGM_RATE_REMAIN, &tv, sizeof(tv));
case PGM_IO_STATUS_WOULD_BLOCK:
/* select for next event */
block:
#ifndef _WIN32
fds = terminate_pipe[0] + 1;
FD_ZERO(&readfds);
FD_SET(terminate_pipe[0], &readfds);
pgm_select_info (sock, &readfds, NULL, &fds);
fds = select (fds, &readfds, NULL, NULL, PGM_IO_STATUS_WOULD_BLOCK == status ? NULL : &tv);
#else
dwTimeout = PGM_IO_STATUS_WOULD_BLOCK == status ? INFINITE : (DWORD)((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
dwEvents = WaitForMultipleObjects (n_handles, waitHandles, FALSE, dwTimeout);
switch (dwEvents) {
case WAIT_OBJECT_0+1: WSAResetEvent (recvEvent); break;
case WAIT_OBJECT_0+2: WSAResetEvent (pendingEvent); break;
default: break;
}
#endif /* !_WIN32 */
break;
default:
if (pgm_err) {
fprintf (stderr, "%s\n", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!is_terminated);
puts ("Message loop terminated, cleaning up.");
/* cleanup */
#ifndef _WIN32
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WSACloseEvent (recvEvent);
WSACloseEvent (pendingEvent);
CloseHandle (terminate_event);
#endif /* !_WIN32 */
if (sock) {
puts ("Destroying PGM socket.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown ();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
puts ("PGM daytime service");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
static struct option long_options[] = {
{ "network", required_argument, NULL, 'n' },
{ "service", required_argument, NULL, 's' },
{ "port", required_argument, NULL, 'p' },
{ "speed-limit", required_argument, NULL, 'r' },
{ "enable-pgmcc", no_argument, NULL, 'c' },
{ "enable-loop", no_argument, NULL, 'l' },
{ "enable-fec", required_argument, NULL, 'f' },
{ "list", no_argument, NULL, 'i' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int c;
while ((c = getopt_long (argc, argv, "s:n:p:r:cf:N:K:P:lih", long_options, NULL)) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'r': max_rte = atoi (optarg); break;
case 'c': use_pgmcc = TRUE; break;
case 'f':
use_fec = TRUE;
switch (optarg[0]) {
case 'p':
case 'P':
proactive_packets = 1;
break;
case 'b':
case 'B':
proactive_packets = 1;
case 'o':
case 'O':
use_ondemand_parity = TRUE;
break;
}
break;
case 'N': rs_n = atoi (optarg); break;
case 'K': rs_k = atoi (optarg); break;
case 'P': proactive_packets = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?':
usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
const int flags = fcntl (terminate_pipe[0], F_GETFL);
fcntl (terminate_pipe[0], F_SETFL, flags | O_NONBLOCK);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminateEvent = WSACreateEvent();
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* service loop */
do {
time_t now;
time (&now);
const struct tm* time_ptr = localtime(&now);
#ifndef _WIN32
char s[1024];
const size_t slen = strftime (s, sizeof(s), TIME_FORMAT, time_ptr);
const int status = pgm_send (sock, s, slen + 1, NULL);
#else
char s[1024];
const size_t slen = strftime (s, sizeof(s), TIME_FORMAT, time_ptr);
wchar_t ws[1024];
size_t wslen = MultiByteToWideChar (CP_ACP, 0, s, slen, ws, 1024);
char us[1024];
size_t uslen = WideCharToMultiByte (CP_UTF8, 0, ws, wslen + 1, us, sizeof(us), NULL, NULL);
const int status = pgm_send (sock, us, uslen + 1, NULL);
#endif
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
#ifndef _WIN32
sleep (1);
#else
Sleep (1 * 1000);
#endif
} while (!is_terminated);
/* cleanup */
puts ("Waiting for NAK thread.");
#ifndef _WIN32
pthread_join (nak_thread, NULL);
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WaitForSingleObject (nak_thread, INFINITE);
CloseHandle (nak_thread);
WSACloseEvent (terminateEvent);
#endif /* !_WIN32 */
if (sock) {
puts ("Closing PGM sock.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
static struct option long_options[] = {
{ "network", required_argument, NULL, 'n' },
{ "service", required_argument, NULL, 's' },
{ "port", required_argument, NULL, 'p' },
{ "speed-limit", required_argument, NULL, 'r' },
{ "enable-loop", no_argument, NULL, 'l' },
{ "enable-fec", required_argument, NULL, 'f' },
{ "list", no_argument, NULL, 'i' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int c;
while ((c = getopt_long (argc, argv, "s:n:p:r:f:K:N:lih", long_options, NULL)) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'r': max_rte = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?':
usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
if (create_sock())
{
while (optind < argc) {
const int status = pgm_send (sock, argv[optind], strlen (argv[optind]) + 1, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
optind++;
}
}
/* cleanup */
if (sock) {
pgm_close (sock, TRUE);
sock = NULL;
}
pgm_shutdown();
return EXIT_SUCCESS;
}
