//
// register_sighandler
//
static void register_sighandler (void)
{
ACE_Sig_Action sa (&server_sighandler);
sa.register_action (SIGINT);
sa.register_action (SIGTERM);
}
//
// register_sighandler
//
static void register_sighandler (void)
{
CUTS_TEST_TRACE ("register_sighandler (void)");
ACE_Sig_Action sa (&server_sighandler);
sa.register_action (SIGINT);
sa.register_action (SIGTERM);
}
void InitContext()
{
#if !defined(WIN32)
//avoid SIGPIPE
static ACE_Sig_Action no_sigpipe ((ACE_SignalHandler) SIG_IGN);
static ACE_Sig_Action original_action;
no_sigpipe.register_action (SIGPIPE, &original_action);
#endif
int ret = ACE::set_handle_limit(-1);//client handler (must be BIG)
}
int
ACE_TMAIN (int argc, ACE_TCHAR *[])
{
// If argc > 1 then allow multiple handlers per-signal, else just
// allow 1 handler per-signal.
ACE_Sig_Handlers multi_handlers;
#if defined (ACE_WIN32)
ACE_WFMO_Reactor reactor_impl (argc > 1
? &multi_handlers
: (ACE_Sig_Handler *) 0);
#else
ACE_Select_Reactor reactor_impl (argc > 1
? &multi_handlers
: (ACE_Sig_Handler *) 0);
#endif /* ACE_WIN32 */
ACE_Reactor reactor (&reactor_impl);
if (argc > 1)
{
// Register an "external" signal handler so that the
// ACE_Sig_Handlers code will have something to incorporate!
ACE_SignalHandler eh = (ACE_SignalHandler) external_handler;
ACE_Sig_Action sa (eh);
sa.register_action (SIGINT);
}
// Create a bevy of handlers.
Sig_Handler_1 h1 (reactor, "howdy");
Sig_Handler_1 h2 (reactor, "doody");
Sig_Handler_2 h3 (reactor, "tutty");
Sig_Handler_2 h4 (reactor, "fruity");
// Wait for user to type SIGINT and SIGQUIT.
for (;;)
{
ACE_DEBUG ((LM_DEBUG,
"\nwaiting for SIGINT or SIGQUIT\n"));
if (reactor.handle_events () == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"handle_events"));
}
ACE_NOTREACHED (return 0);
}
// Listing 3
// Listing 2 code/ch11
static void register_actions ()
{
ACE_TRACE ("::register_actions");
ACE_Sig_Action sa (reinterpret_cast <ACE_SignalHandler> (my_sighandler));
// Make sure we specify that SIGUSR1 will be masked out
// during the signal handler's execution.
ACE_Sig_Set ss;
ss.sig_add (SIGUSR1);
sa.mask (ss);
// Register the same handler function for these
// two signals.
sa.register_action (SIGUSR1);
sa.register_action (SIGUSR2);
}
int main(int argc, char* argv[]) {
GameManager* manager = GameManager::instance();
// Process the command line switches. Look at every second arg for
// a recognizable flag.
const int NAME_FLAG = 0, FILE_FLAG = 1;
int flag;
bool parse_error = false;
string error_msg;
for (int i = 2; i < argc; i += 2) {
if (!strcmp("-n", argv[i-1])) flag = NAME_FLAG;
else if (!strcmp("-f", argv[i-1])) flag = FILE_FLAG;
else {
parse_error = true;
error_msg = "Unknown flag.";
break;
}
if ((argv[i][0] == '-') || (strlen(argv[i]) == 0)) {
parse_error = true;
error_msg = "Missing parameter for flag.";
break;
}
switch (flag) {
case NAME_FLAG:
manager->name = argv[i];
break;
case FILE_FLAG:
if (manager->parse_file(argv[i]) != 0) {
parse_error = true;
error_msg = "Could not parse defintion file.";
}
break;
}
}
if (parse_error) {
std::cout << "ERROR: " << error_msg << std::endl;
std::cout << "Usage: client -n <player name> -f <definition file> " << std::endl;
return -1;
}
PlayerConnector player_connector(ACE_Reactor::instance());
// keep track of the number of open connections so we can
// kill the client if no connections were able to be opened
int num_open_connections = manager->games.size();
for (unsigned int i = 0; i < manager->games.size(); ++i) {
PlayerGame* game = manager->games[i];
ACE_INET_Addr peer_addr;
if (peer_addr.set(game->port, game->host.c_str()) == -1) {
std::cout << "Unable to set server address for " << game->host << ":" << game->port << std::endl;
num_open_connections--;
continue;
}
peer_addr.addr_to_string (buffer, MTU);
std::cout << "Address and port: " << buffer << std::endl;
PlayerSvcHandler* connector_handler = &(game->handler);
if (player_connector.connect (connector_handler, peer_addr) == -1) {
std::cout << "Couldn't connect to server.\n" << std::endl;
num_open_connections--;
}
}
if (num_open_connections == 0) return -1; // kill the client if no connections were able to be opened
// Implement signal handler.
ACE_Sig_Action sa;
sa.register_action (SIGINT);
SigHandler sh (ACE_Reactor::instance());
while (!SigHandler::sigint_fired()) {
ACE_Reactor::instance()->handle_events();
}
if (GameManager::instance() != NULL) {
delete GameManager::instance();
}
return 0;
}
