int main(int argc, char* argv[])
{
Logger* stderr_logger = stderr_logger_create();
logger_set_next(stderr_logger, stdout_logger_create());
logger_message(stderr_logger, "information", DEBUG);
logger_message(stderr_logger, "Notice", NOTICE);
logger_message(stderr_logger, "Error", ERR);
logger_destroy(stderr_logger);
return 0;
}
bool client_manager_init(int port)
{
logger_message("[CLIENT] Manager starting ...");
if (!(g_client_manager = malloc(sizeof(t_client_manager))))
return false;
list_init(&g_client_manager->clients);
list_init(&g_client_manager->commands);
if (!network_init()
|| !socket_init(&g_client_manager->listen)
|| !network_listen_to(&g_client_manager->listen, port, &client_connect))
return false;
logger_message("[CLIENT] Manager started");
return true;
}
t_bool init_map(t_kernel *kernel, int width, int height)
{
int i;
int j;
int it;
if (!(kernel->game.map = malloc(sizeof(t_map))))
return (FALSE);
kernel->game.map->width = width;
kernel->game.map->height = height;
if (!(kernel->game.map->map
= (t_case **)malloc(sizeof(t_case *) * (height) + 1)))
return (FALSE);
for (i = 0; i < height; i++)
{
if (!(kernel->game.map->map[i]
= (t_case *)malloc(sizeof(t_case) * (width + 1))))
return (FALSE);
for (j = 0; j < width; j++)
{
for (it = 0; it < ITEM_TYPE; ++it)
kernel->game.map->map[i][j].inventory.items[it] = random_res();
kernel->game.map->map[i][j].players = NULL;
}
}
logger_message("{MAP} Initialisation");
return (TRUE);
}
void client_food_dead(t_client *client)
{
logger_message("[CLIENT] Client %i starved ... dead!", CLP_ID(client));
player_free(client->player);
client->player = NULL;
client_send(client, "mort");
client_unconnect(client);
}
/* Connection management thread */
static void *server_conn_thread( void *p )
{
server_conn_desc_t *conn_desc = (server_conn_desc_t *)p;
for ( ;; )
{
/* Wait for some activity */
int retv = rd_with_notify_wait(conn_desc->m_rdwn);
if (!retv)
{
logger_error(player_log, 0,
_("Connection select failed: %s"),
strerror(errno));
break;
}
/* Notification */
if (retv & RDWN_NOTIFY_READY)
{
char nv;
if (read(RDWN_NOTIFY_READ_FD(conn_desc->m_rdwn), &nv, 1) <= 0)
{
/* Some error */
break;
}
/* Exit */
if (nv == SERVER_NOTIFY_EXIT)
break;
/* Handle notification */
server_conn_client_notify(conn_desc, nv);
}
/* Input from client */
if (retv & RDWN_READ_READY)
{
ssize_t sz = recv(conn_desc->m_socket,
&conn_desc->m_buf, sizeof(conn_desc->m_buf) - 1, 0);
if (sz == -1)
continue;
else if (sz == 0)
break;
conn_desc->m_buf[sz] = 0;
if (!server_conn_parse_input(conn_desc))
break;
}
}
logger_message(player_log, 0, _("Closing connection"));
/* Destroy the connection */
server_conn_desc_free(conn_desc);
return NULL;
} /* End of 'server_conn_thread' function */
void client_manager_destroy()
{
if (!g_client_manager)
return;
logger_message("[CLIENT] Manager destroy");
list_foreach(&g_client_manager->clients, (feach) &client_destroy);
list_clear(&g_client_manager->clients);
list_free(&g_client_manager->commands);
network_destroy();
free(g_client_manager);
g_client_manager = NULL;
}
int session_destroy(void)
{
t_session *session;
logger_message("[SESSION] Stop session service");
session = session_get_session();
list_foreach(&(session->in), &delete_instruction_in);
list_clear(&(session->in));
list_foreach(&(session->out), &delete_instruction_out);
list_clear(&(session->out));
return (0);
}
/** Write an entry to the log (va_list variant).
*
* @param ctx Log to use (use LOG_DEFAULT if you have no idea what it means).
* @param level Severity level of the message.
* @param fmt Format string in printf-like format (without trailing newline).
* @param args Arguments.
*/
void log_msgv(log_t ctx, log_level_t level, const char *fmt, va_list args)
{
assert(level < LVL_LIMIT);
char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
if (message_buffer == NULL)
return;
vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
logger_message(logger_session, ctx, level, message_buffer);
free(message_buffer);
}
void
logger_printf(const TCHAR *format, ...)
{
va_list ap;
TCHAR *tmp;
va_start(ap, format);
tmp = tcsdup_vprintf(format, ap);
va_end(ap);
logger_message(tmp);
free(tmp);
}
static t_bool add_team(t_kernel *kernel, char *teamname)
{
t_team *team;
if (!(team = malloc(sizeof(t_team))))
return (FALSE);
strcpy(team->name, teamname);
if (!(team->players = list_create()))
return (FALSE);
team->place_left = kernel->options.max_clients;
if (FALSE == list_push_back(&(kernel->game.teams), team))
return (FALSE);
logger_message("{TEAM} Create %s", teamname);
return (TRUE);
}
void __cdecl
_tmain(int argc, _TCHAR *argv[])
{
SERVICE_TABLE_ENTRY DispatchTable[] =
{
{ TEXT(""), ServiceMain },
{ NULL, NULL },
};
if (argc == 2 && lstrcmpi(argv[1], TEXT("install")) == 0)
{
do_install();
return;
}
if (argc == 2 && lstrcmpi(argv[1], TEXT("uninstall")) == 0)
{
do_uninstall();
return;
}
if (argc == 2 && lstrcmpi(argv[1], TEXT("test")) == 0)
{
logger_message("hello world!");
return;
}
if (!StartServiceCtrlDispatcher(DispatchTable))
{
if (GetLastError() != ERROR_FAILED_SERVICE_CONTROLLER_CONNECT)
{
fatal_win32_error(TEXT("StartServiceCtrlDispatcher"));
}
fprintf(stderr, "Error: no option specified\n");
fprintf(stderr, "Usage: %s install\n", argv[0]);
exit(1);
}
}
/* The main server thread function
* It is responsible for accepting connections and launching
* per-connection threads */
static void *server_thread( void *p )
{
for ( ;; )
{
/* Wait for input */
int retv = rd_with_notify_wait(server_rdwn);
if (!retv)
{
logger_error(player_log, 0,
_("Server select failed: %s"),
strerror(errno));
return NULL;
}
/* Exit */
if (retv & RDWN_NOTIFY_READY)
break;
/* Try to accept connection */
if (retv & RDWN_READ_READY)
{
server_conn_desc_t *conn_desc = NULL;
int conn_socket = -1;
int err;
conn_socket = accept(server_socket, NULL, NULL);
if (conn_socket == -1)
{
logger_error(player_log, 0,
_("Server socket accept failed: %s"),
strerror(errno));
goto failure;
}
logger_message(player_log, 0, _("Received a connection"));
/* Start the connection thread */
conn_desc = server_conn_desc_new(conn_socket);
if (!conn_desc)
{
close(conn_socket);
goto failure;
}
err = pthread_create(&conn_desc->m_tid, NULL,
server_conn_thread, conn_desc);
if (err)
{
logger_error(player_log, 0,
_("Server connection thread create failed: %s"),
strerror(err));
goto failure;
}
continue;
failure:
if (conn_desc)
server_conn_desc_free(conn_desc);
continue;
}
}
return NULL;
} /* End of 'server_thread' function */
/* Start the server */
bool_t server_start( void )
{
struct sockaddr_in addr;
int err, i;
int server_port = cfg_get_var_int(cfg_list, "server-port");
if (!server_port)
server_port = 0x4D50; /* 'MP' / 19792 */
int server_port_pool_size = cfg_get_var_int(cfg_list, "server-port-pool-size");
if (!server_port_pool_size)
server_port_pool_size = 10;
logger_message(player_log, 0, _("Starting the server at port %d"), server_port);
/* Create socket */
server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1)
{
logger_error(player_log, 0,
_("Server socket creation failed: %s"),
strerror(errno));
goto failed;
}
/* Bind */
for ( int i = 0; i < server_port_pool_size; i++, server_port++ )
{
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(server_port);
addr.sin_family = AF_INET;
if (bind(server_socket, (struct sockaddr*)&addr, sizeof(addr)) != -1)
goto bind_succeeded;
else
logger_error(player_log, 0,
_("Server socket bind at port %d failed: %s"),
server_port, strerror(errno));
}
bind_succeeded:
logger_message(player_log, 0, _("Server listening at port %d"), server_port);
/* Listen */
if (listen(server_socket, 5) == -1)
{
logger_error(player_log, 0,
_("Server socket listen failed: %s"),
strerror(errno));
goto failed;
}
/* Create rdwn */
server_rdwn = rd_with_notify_new(server_socket);
if (!server_rdwn)
{
logger_error(player_log, 0,
_("Server notification pipe create failed: %s"),
strerror(errno));
goto failed;
}
/* Start the main thread */
err = pthread_create(&server_tid, NULL, server_thread, NULL);
if (err)
{
logger_error(player_log, 0,
_("Server thread create failed: %s"),
strerror(err));
goto failed;
}
/* Install hook handler */
server_hook_id = pmng_add_hook_handler(player_pmng, server_hook_handler);
return TRUE;
failed:
if (server_socket != -1)
{
close(server_socket);
server_socket = -1;
}
if (server_rdwn)
{
rd_with_notify_free(server_rdwn);
server_rdwn = NULL;
}
return FALSE;
} /* End of 'server_start' function */
static void
SvcInit(DWORD dwArgc, TCHAR *lpszArgv[])
{
MyParams params = {0};
/* create an event; this event will be raised when we're told
* to shut down */
stopEvent = CreateEvent(
NULL, /* default security attributes */
TRUE, /* manual reset event */
FALSE, /* not signaled */
NULL); /* no name */
if (stopEvent == NULL)
{
report_status(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
/* look in registry for guidance */
get_registry_params(lpszArgv[0], ¶ms);
logger_message(TEXT("startup: version 2011.03.21"));
report_status(SERVICE_RUNNING, NO_ERROR, 0);
while(1)
{
if (params.delay != 0)
{
HANDLE hTimer;
LARGE_INTEGER li = {0};
const __int64 nTimerUnitsPerSecond = 10000000;
int nsecs_delay;
if (params.hour != 101)
{
struct tm *tm;
time_t t;
int nhours_delay;
time(&t);
tm = localtime(&t);
nhours_delay = (params.hour + 24 - tm->tm_hour) % 24;
nsecs_delay = params.delay + 3600 * nhours_delay;
}
else
{
nsecs_delay = params.delay;
}
logger_printf(TEXT("waiting for %d seconds"), nsecs_delay);
li.QuadPart = -(nsecs_delay * nTimerUnitsPerSecond);
hTimer = CreateWaitableTimer(NULL, FALSE, NULL);
SetWaitableTimer(hTimer, &li, 0, NULL, NULL, TRUE);
{
HANDLE handles[2];
DWORD dwEvent;
handles[0] = stopEvent;
handles[1] = hTimer;
dwEvent = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
if (dwEvent == WAIT_OBJECT_0 + 0)
{
/* stop the service */
logger_message(TEXT("received stop signal"));
report_status(SERVICE_STOPPED, NO_ERROR, 0);
CloseHandle(hTimer);
return;
}
else if (dwEvent != WAIT_OBJECT_0 + 1)
{
/* FIXME- error returned by WaitForMultipleObjects */
}
}
CloseHandle(hTimer);
}
if (check_for_active_sessions())
{
logger_printf(TEXT("station appears to be in use"));
continue;
}
break;
}
if (params.script != NULL)
{
logger_printf(TEXT("resetting the idle timer"));
SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_CONTINUOUS);
if (params.status_window_cmd != NULL)
{
logger_printf(TEXT("launching status window process"));
launch_status_window(params.status_window_cmd);
}
logger_printf(TEXT("launching script %s"), params.script);
create_process(params.script);
}
else
{
logger_message(TEXT("nothing to run"));
}
{
WaitForSingleObject(stopEvent, INFINITE);
logger_message(TEXT("received stop signal"));
report_status(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
}