/**
* Listen on the various configured interfaces
*/
int child_listening_sockets(vector_t listen_addrs, uint16_t port)
{
int ret;
ssize_t i;
assert (port > 0);
if (listen_fds == NULL) {
listen_fds = vector_create();
if (listen_fds == NULL) {
log_message (LOG_ERR, "Could not create the list "
"of listening fds");
return -1;
}
}
if ((listen_addrs == NULL) ||
(vector_length(listen_addrs) == 0))
{
/*
* no Listen directive:
* listen on the wildcard address(es)
*/
ret = listen_sock(NULL, port, listen_fds);
return ret;
}
for (i = 0; i < vector_length(listen_addrs); i++) {
const char *addr;
addr = (char *)vector_getentry(listen_addrs, i, NULL);
if (addr == NULL) {
log_message(LOG_WARNING,
"got NULL from listen_addrs - skipping");
continue;
}
ret = listen_sock(addr, port, listen_fds);
if (ret != 0) {
return ret;
}
}
return 0;
}
static void async_acceptor(boost::asio::yield_context yielder, int port, RSA * privatekey, X509 * x509_cert)
{
// 创建 tcp 端口，进入监听
boost::asio::ip::tcp::acceptor listen_sock(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v6(), port));
while(true)
{
boost::system::error_code ec;
boost::shared_ptr<boost::asio::ip::tcp::socket> client_sock(new boost::asio::ip::tcp::socket(io_service));
listen_sock.async_accept(*client_sock, yielder[ec]);
// 进入 client 处理
if(!ec)
boost::asio::spawn(io_service, boost::bind(&process_client, _1, client_sock, privatekey, x509_cert));
}
}
void debug_loop(int argc, char *argv[], void (*loop)(void)) {
listen_port = atoi(argv[1]);
argc-=2;
argv++; argv++;
int listen_fd = listen_sock();
struct sockaddr_in cli_addr;
socklen_t cli_addr_len;
if(argc >= 1 && !strcmp(argv[0], "-f")) {
argc--;
argv++;
fprintf(stderr, "Start fork-pool\r\n");
while(1) {
pid_t child;
if((child = fork()) == 0) {
int cli_sock = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
in_fd = out_fd = cli_sock;
// setsockopt(in_fd, SOL_SOCKET, SO_LINGER, &true_, sizeof(true_));
loop();
shutdown(cli_sock, SHUT_RDWR);
_exit(0);
} else {
int stat_loc;
struct rusage rusage;
wait4(child, &stat_loc, 0, &rusage);
if(WIFSIGNALED(stat_loc)) {
fprintf(stderr, "Child process was signalled by %d\r\n", WTERMSIG(stat_loc));
} else if(WIFEXITED(stat_loc)) {
if(WEXITSTATUS(stat_loc) != 0)
fprintf(stderr, "Child process exited with code %d\r\n", WEXITSTATUS(stat_loc));
} else {
fprintf(stderr, "Child process exited due to unknown reason\r\n");
}
fprintf(stderr, "\r\n");
}
}
} else {
int cli_sock = accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
in_fd = out_fd = cli_sock;
loop();
_exit(0);
}
}
object *socket::listen(integer *queue)
{
if (socket_val < 0)
{
exceptions::SocketError *exc = exceptions::SocketError::Create(
1,
new string("Socket already closed.")
);
exc->throw_exception();
}
int ret = listen_sock(socket_val, queue->val);
if (ret < 0)
{
exceptions::SocketError *exc = exceptions::SocketError::Create(
1,
new string("Error while listening on socket.")
);
exc->throw_exception();
}
return new boolean(true);
}
int TCP_sock_rcv(in_port_t port){
int sock, sock_rcv;
int porta;
struct sockaddr_in Local, From;
char ipstr[15];
porta = ntohs(port);
sock = get_sock(SOCK_STREAM);
set_sock(sock);
name_sock(&Local, htonl(INADDR_ANY), port);
bind_sock(sock, &Local);
listen_sock(sock);
printf("Attendo una connessione TCP sulla porta %d\n\n", porta);
sock_rcv = accept_sock(sock, &From);
inet_ntop(AF_INET, &From.sin_addr, ipstr,(socklen_t)15); /* conversione a stringa dell'ip per stamparlo */
printf("Connessione TCP da %s : %d\n\n", ipstr, ntohs(From.sin_port));
return sock_rcv;
}
int main(int argc, char *argv[])
{
if (argc != 2)
{
printf("usage: ./server <#port>\n");
exit(EXIT_FAILURE);
}
int port = atoi(argv[1]);
/* SIGCHLD handler */
struct sigaction sigchld;
sigchld.sa_handler = chld_handler;
sigemptyset(&sigchld.sa_mask);
sigchld.sa_flags = 0;
sigaction(SIGCHLD,&sigchld,NULL);
int listenfd = bind_sock(port);
listen_sock(listenfd);
handle_connection(listenfd);
return 0;
}
int child_listening_sock (uint16_t port)
{
listenfd = listen_sock (port, &addrlen);
return listenfd;
}
int main(int argc, char **argv){
int mc_sock;
addr_t mc_addr;
ev_io mc_io;
sophiadb_t * db;
int c;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"max-clients", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "n:Vc:t", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'c':
confilename = optarg;
break;
case 'n':
max_clients = atoi(optarg);
break;
case 'V':
printf("Version %s\n", MYMC_VERSION);
exit(0);
case 't':
is_trace = 1;
break; default:
usage(argv[0], c == 'h' ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
if (confilename)
parse(confilename, &server_ctx);
else
parse( CONFIGFILE, &server_ctx);
//assert(server_ctx.logfile);
//assert(server_ctx.listen);
if (!server_ctx.listen) {
perror("undefined listen port");
exit(1);
}
flog = server_ctx.logfile ? fopen(server_ctx.logfile, "a+") : fopen("error.log", "a+");
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server started at %s\n",ctime(<));
} else {
perror("can not create log file");
exit(1);
}
daemonize(server_ctx.is_demonize, server_ctx.pidfile, server_ctx.username);
set_rlimit();
ignore_sigpipe();
init_addr(&mc_addr, server_ctx.listen);
mc_sock = socket(mc_addr.pf_family, SOCK_STREAM, 0);
if (mc_sock < 0) {
perror("can't create socket");
exit(1);
}
listen_sock(mc_sock, &mc_addr);
//TODO
if (is_trace)
printf("pid=%ld\n\n", (long)getpid());
clients = calloc(max_clients, sizeof(fd_ctx));
if (!clients) {
perror_fatal("Cannot allocate array for client descriptors!");
}
int i=0;
while(i < max_clients) {
if(clients[i].mc)
printf("init err %i\n", i);
i++;
}
db = db_init(&server_ctx);
assert(db);
struct ev_loop *loop = ev_default_loop(0);
assert(loop);
ev_set_userdata(loop,(void*)db);
ev_io_init( &mc_io, memcached_on_connect, mc_sock, EV_READ);
ev_io_start(loop, &mc_io);
struct ev_timer timeout_watcher;
ev_init(&timeout_watcher, periodic_watcher);
timeout_watcher.repeat = TIME_CHECK_INTERVAL;
ev_timer_again(loop, &timeout_watcher);
struct ev_signal signal_watcher,signal_watcher2;
// ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
// ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher, sigint_cb, SIGTERM);
ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher2, sighup_cb, SIGHUP);
ev_signal_start (loop, &signal_watcher2);
//start server
time(&stats.uptime);
gettimeofday(&t_start, NULL);
// event loop
ev_loop(loop, 0);
cllear_mc_all();
close(mc_sock);
if (clients)
free(clients);
//ev_loop_destroy(loop);
destroy(db);
if (mc_addr.a_addr) free(mc_addr.a_addr);
if (server_ctx.pidfile) {
if( unlink(server_ctx.pidfile))
printf("cannot delete pid file %s %s\n",server_ctx.pidfile, strerror(errno));
}
free_config();
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server finis Ok at %s\n",ctime(<));
fclose(flog);
}
return 0;
}
VOID Thread (PVOID pvoid)
{
listenfd = listen_sock(port, &addrlen);
close(listenfd);
//return listenfd;
}
int
main(int argc, char **argv)
{
int x;
umask(0077);
/* initialize stuff */
memset(&me, 0, sizeof(me));
me.argc = argc;
me.argv = argv;
me.start = time(NULL);
me.settime = time(NULL) + (60*60*4);
/* setup signals */
signal(SIGHUP, do_signal);
signal(SIGINT, do_signal);
signal(SIGQUIT, do_signal);
signal(SIGILL, do_signal);
signal(SIGTRAP, do_signal);
signal(SIGBUS, do_signal);
signal(SIGSEGV, do_signal);
signal(SIGSYS, do_signal);
signal(SIGALRM, SIG_IGN);
signal(SIGTERM, do_signal);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
while ((x = getopt(me.argc, me.argv, "qd")) != -1) {
switch (x) {
case 'd':
me.debug = 1;
break;
}
}
if (me.debug == 0)
printf("%s by %s\n", VER_STR, MYEMAIL);
if (read_conf())
err(1, "ERROR! Unable to read configuration file");
if (!me.servname || !me.servdesc)
errx(1, "ERROR! Your M: line is invalid, incomplete, or missing!");
for (x = 0; x < ALL; x++)
if (!me.sclients[x].nick || check_nick(NULL, me.sclients[x].nick) ||
!me.sclients[x].username || check_um(NULL, me.sclients[x].username) ||
!me.sclients[x].realname || check_rm(NULL, me.sclients[x].realname))
errx(1, "ERROR! Your N: line for %d is invalid, incomplete, or missing!", x);
if (!me.chans[0])
errx(1, "ERROR! You need at least one R: line in %s", CONF);
if (!(me.logfd = fopen(PIDFILE, "w")))
err(1, "ERROR! Unable to open pidfile");
fprintf(me.logfd, "%d\n", getpid());
fclose(me.logfd);
if (!(me.logfd = fopen(LOGFILE, "a")))
err(1, "ERROR! Unable to open logfile");
if ((x = read_db(0)) > 0)
err(1, "ERROR! Unable to read %s", databases[x]);
if (me.ip.s_addr == NULL) {
if (!self_lookup())
err(1, "ERROR! self-lookup failed!");
else
printf("WARNING: no vhost defined in conf, using default of %s\n", inet_ntoa(me.ip));
}
if (me.debug == 0)
switch (me.pid = fork())
{
case -1:
err(1, "ERROR! Unable to fork");
case 0:
for (x = 0; x < 12; x++)
if (x != fileno(me.logfd))
close(x);
break;
default:
printf("forked into the background: pid = %d\n", me.pid);
return 0;
}
listen_sock(7272);
try_next_hub();
add_event(1, SERVTIMEOUT / 2, &ping_hub);
add_event(1, CONNTIMEOUT / 3, &cleanup_dcc);
io_loop();
/* NOTREACHED */
exit(0);
}
int main(int argc, char* argv[])
{
parseArgs(argc, argv);
config.Load(config_file);
DPRINT(INFO, "Warmux index server version %i", VERSION);
DPRINT(INFO, "%s", wx_clock.DateStr());
Env::SetConfigClass(config);
Env::SetWorkingDir();
bool local, r;
r = config.Get("local", local);
if (!r)
PRINT_FATAL_ERROR;
if (!local)
DownloadServerList();
Env::SetChroot();
Env::MaskSigPipe();
// Set the maximum number of connection
Env::SetMaxConnection();
Env::SetupAutoReloadConf();
stats.Init();
int port = 0;
config.Get("port", port);
Server listen_sock(port);
// Set of socket where an activity have been detected
fd_set acting_sock_set;
if (!local)
sync_slave.Start();
while(1)
{
wx_clock.HandleJobs(local);
sync_slave.CheckGames();
struct timeval timeout;
memset(&timeout, 0, sizeof(timeout));
timeout.tv_sec = 1;
timeout.tv_usec = 0;
acting_sock_set = listen_sock.GetSockSet();
// Lock the process until activity is detected
if ( select(FD_SETSIZE, &acting_sock_set, NULL, NULL, &timeout) < 1 )
{
// Timeout to check for other games on other servers
if(timeout.tv_sec != 0 && timeout.tv_usec != 0)
PRINT_FATAL_ERROR;
}
// Find the socket where activity have been detected:
// First check for already established connections
for(std::multimap<std::string,Client*>::iterator client = clients.begin();
client != clients.end();
++client)
{
client->second->CheckState();
if( ! client->second->connected )
{
// Connection closed
DPRINT(CONN, "Closind FD %u from client %p\n", client->second->GetFD(), client->second);
listen_sock.CloseConnection( client->second->GetFD() );
delete client->second;
clients.erase(client);
DPRINT(CONN, "%i connections up!", (int)clients.size());
break;
}
if( FD_ISSET( client->second->GetFD(), &acting_sock_set) )
{
if( ! client->second->Receive() ) {
DPRINT(CONN, "Nothing received from client %p, disconnecting!", client->second);
client->second->connected = false;
}
// Exit as the clients list may have changed
break;
}
}
// Then check if there is any new incoming connection
if( FD_ISSET(listen_sock.GetFD(), &acting_sock_set) )
{
Client* client = listen_sock.NewConnection();
if(client != NULL)
clients.insert(std::make_pair("unknown", client ));
DPRINT(CONN, "%i connections up!", (int)clients.size());
// Exit as the 'clients' list may have changed
}
}
}
