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, ""); 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 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[]) { // Get all command line options AgentServerCmdOptions opts; if (!opts.parseArgs(argc, argv)) { exit(0); } // Log file and config file pointers char *log_file; char *ini_config_file; // If ini file is defined, invoke Global Config Parser ini_config_file = opts.getIniConfigFile(); if (ini_config_file != NULL) { bool parse_status = GlobalConfig::parse(std::string(ini_config_file), global_config); if (!parse_status) { std::cerr << "INI config file parse failed" << std::endl; exit(0); } // Set logger information std::string log_file_str = global_config.grpc_log_file_path + "/" + global_config.grpc_log_file_name; opts.setLogFile(log_file_str); // Set system mode information if (global_config.system_mode == SYSTEM_MODE_PROC) { opts.setProcMode(true); } else if (global_config.system_mode == SYSTEM_MODE_FILE) { opts.setFileMode(true); std::string file_str = global_config.system_file_path + "/" + global_config.system_file_name; opts.setFileName(file_str); } else { opts.setNullMode(true); } } // Validate if logger file was specified log_file = opts.getLogFile(); if (log_file == NULL) { char *env_rp = std::getenv("ROOTPATH"); if (env_rp != NULL) { // if ROOTPATH env variable is set, set default log path std::string log_file_str = (std::string)env_rp + "/logs/" + AGENTSERVER_LOGFILE; log_file = (char *)log_file_str.c_str(); std::cout << "Log file not specified using -l option. " << "Default = " << log_file << std::endl; } else { std::cerr << "Please setup ROOTPATH environment variable " << "or use -l to set log file." << std::endl; exit(0); } } // Create a logger AgentServerLog *logger; logger = new AgentServerLog(log_file); logger->enable(); // Pid check for on-box mode if (global_config.running_mode == RUNNING_MODE_ON_BOX){ if (pid_lock(NA_GRPCD_PID, logger) < 0) { logger->log("Already running. Check pid. Terminating"); exit(0); } } // Initialize interface with Mosquitto Library mosqpp::lib_init(); // Initialize all the oc translators lib_oc_init(); OpenConfig::display(logger); // Create a handle for the system AgentSystem *sys_handle = CreateSystemHandle(&opts, logger); // On start up/restart execute necessary functionality if (!on_startup(logger, sys_handle)) { logger->log("Failed in startup module. Terminating"); exit(0); } // Create a PathValidator object PathValidator *path_validator = NULL; if (global_config.validate_ocpaths) { path_validator = new PathValidator(logger); bool status = path_validator->build_path_information_db( global_config.ocpath_file_path + "/" + global_config.ocpath_file_name); if (!status) { logger->log("PathValidator build_path failed. Terminating"); exit(0); } path_validator->print_path_information_db(); } // Start a UDP thread if requested if (global_config.udp_server_module) { udpreceiver = new UdpReceiver(logger, std::stoi(global_config.udp_server_ip), global_config.udp_server_port); std::thread udpreceiverthread([]() { (*udpreceiver)(); }); udpreceiverthread.detach(); } // Start the server RunServer(logger, sys_handle, path_validator); }
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, ""); #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, ""); 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 !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; }