int main(int argc, char* argv[])
{
#if defined(WIN32) || defined(__WIN32__)
MASTER_FD master;
init(argc, argv);
{
char buff[1024];
if (WSAStartup(0x0202,(WSADATA *) &buff[0]))
{
if(verbose){
handle_error(__FILE__, __LINE__);
}
return -1;
}
}
init_master(&master);
InitializeCriticalSection(&master.lock);
logging_name = "FWT Server";
server_loop(
&client_handler, &get_client_data, &get_addr, buf, sock_data,
listen_port, &hello, &master, NULL
);
return 0;
#endif
#if !defined(WIN32) && !defined(__WIN32__)
MASTER_FD master;
init(argc, argv);
init_master(&master);
master.lock = semget(get_key(), 1, 0666 | IPC_CREAT | IPC_EXCL);
if(master.lock == -1){
if(verbose){
handle_error(__FILE__, __LINE__);
}
exit(0);
}
logging_name = "FWT Server";
server_loop(
&client_handler, &get_client_data, &get_addr, buf, sock_data,
listen_port, &hello, &master, NULL
);
return 0;
#endif
}
int main(int argc, char **argv) {
int port, gamespeed;
if (argc < 4) {
fprintf(stdout, "Usage: %s <map> <gamespeed (1-10)> <players> [port]\n", argv[0]);
return -1;
}
if (argc >= 5)
port = atoi(argv[4]);
else
port = SERVER_PORT_DEFAULT;
fprintf(stderr, "Listening on port %i...\n", port);
server_init();
gettimeofday(&time_d, NULL);
gamespeed = atoi(argv[2]);
if (server_start(argv[1], atoi(argv[3]), port, gamespeed) == NULL)
return -1;
for (;;) {
server_loop(deltaTime());
#ifdef _WIN32
Sleep(15);
#else
usleep(15000);
#endif
}
return 0;
}
/* Program start */
int main(int argc, char *argv[])
{
int c, local_port;
pid_t pid;
local_port = parse_options(argc, argv);
if (local_port < 0) {
printf("Syntax: %s -l local_port -h remote_host -p remote_port \n", argv[0]);
return 0;
}
if ((server_sock = create_socket(local_port)) < 0) { // start server
perror("Cannot run server");
return server_sock;
}
signal(SIGCHLD, sigchld_handler); // prevent ended children from becoming zombies
signal(SIGTERM, sigterm_handler); // handle KILL signal
switch(pid = fork()) {
case 0:
server_loop(); // daemonized child
break;
case -1:
perror("Cannot daemonize");
return pid;
default:
close(server_sock);
}
return 0;
}
/** OpenOCD runtime meat that can become single-thread in future. It parse
* commandline, reads configuration, sets up the target and starts server loop.
* Commandline arguments are passed into this function from openocd_main().
*/
static int openocd_thread(int argc, char *argv[], struct command_context *cmd_ctx)
{
int ret;
if (parse_cmdline_args(cmd_ctx, argc, argv) != ERROR_OK)
return EXIT_FAILURE;
if (server_preinit() != ERROR_OK)
return EXIT_FAILURE;
ret = parse_config_file(cmd_ctx);
if (ret != ERROR_OK)
return EXIT_FAILURE;
ret = server_init(cmd_ctx);
if (ERROR_OK != ret)
return EXIT_FAILURE;
if (init_at_startup) {
ret = command_run_line(cmd_ctx, "init");
if (ERROR_OK != ret)
return EXIT_FAILURE;
}
server_loop(cmd_ctx);
server_quit();
return ret;
}
int main(int argc, char *argv[]) {
int compare_size = COMPARE_SIZE;
unsigned int maxerr = COMPARE_THRESHOLD;
if (argc < 3) {
fprintf(stdout, "\nERROR: Not enough arguments\n");
usage();
exit(1);
}
char *sql_info = argv[1];
int portno = atoi(argv[2]);
if (!portno) {
fprintf(stdout, "\nERROR: Invalid port\n");
usage();
exit(1);
}
// Work out how many CPUs we have. Default to 2
global_cpu_count = get_cpu_count(stdout);
if (global_cpu_count == 0) {
global_cpu_count = 2;
}
MagickWandGenesis();
server_loop(stdout, sql_info, portno, compare_size, maxerr);
MagickWandTerminus();
/* The final thing that main() should do */
pthread_exit(NULL);
exit(0);
}
void server_main()
{
struct sigaction sa;
int sock;
sock_path = get_socket_path();
sock = create_server_socket(sock_path);
if (sock == -1) {
fprintf(stderr, "Error! Failed to create a server socket: %s\n",
sock_path->data);
exit(1);
}
sa.sa_handler = handle_sigint;
sa.sa_flags = 0;
sigaction(SIGINT, &sa, 0);
clang_index = clang_createIndex(0, 0);
server_loop(sock);
if (clang_tu)
clang_disposeTranslationUnit(clang_tu);
clang_disposeIndex(clang_index);
close(sock);
unlink(sock_path->data);
str_free(sock_path);
}
int main(int argc, char **argv)
{
struct layout layout;
struct opts opts;
memset(&opts, 0, sizeof(opts));
memset(&layout, 0, sizeof(layout));
layout.state.main_selected = -1;
gtk_init(&argc, &argv);
parse_opts(argc, argv, &opts);
aprs_pri_img = gdk_pixbuf_new_from_file("images/aprs_pri_big.png",
NULL);
aprs_sec_img = gdk_pixbuf_new_from_file("images/aprs_sec_big.png",
NULL);
layout.max = 32;
layout.nxt = 0;
layout.elements = calloc(layout.max, sizeof(struct named_element));
make_window(&layout, opts.window);
if (layout.nxt == layout.max) {
fprintf(stderr, "Too many elements\n");
abort();
}
server_loop(&opts, &layout);
return 0;
}
/**
* Server Entry Point
* @param argc Number of Arguments
* @param argv Arguments
* @return OS Error Code
*/
int main(int argc, char * argv[])
{
// Result
int result = 0;
// Create Signal Receiver for CTRL + C
signal(SIGINT, interrupt);
// Create Signal Receiver for kill / killall
signal(SIGTERM, interrupt);
// Create Listening Socket
int server = create_listen_socket(SERVER_PORT);
// Created Listening Socket
if(server != -1)
{
// Notify User
printf("Listening for Connections on TCP Port %u.\n", SERVER_PORT);
// Enter Server Loop
result = server_loop(server);
// Notify User
printf("Shutdown complete.\n");
}
// Return Result
return result;
}
/* normally this is the main() function entry, but if OpenOCD is linked
* into application, then this fn will not be invoked, but rather that
* application will have it's own implementation of main(). */
int openocd_main(int argc, char *argv[])
{
int ret;
/* initialize commandline interface */
command_context_t *cmd_ctx;
cmd_ctx = setup_command_handler();
#if BUILD_IOUTIL
if (ioutil_init(cmd_ctx) != ERROR_OK)
{
return EXIT_FAILURE;
}
#endif
LOG_OUTPUT("\n\nBUGS? Read http://svn.berlios.de/svnroot/repos/openocd/trunk/BUGS\n\n\n");
print_version();
command_context_mode(cmd_ctx, COMMAND_CONFIG);
command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
if (parse_cmdline_args(cmd_ctx, argc, argv) != ERROR_OK)
return EXIT_FAILURE;
ret = parse_config_file(cmd_ctx);
if ( (ret != ERROR_OK) && (ret != ERROR_COMMAND_CLOSE_CONNECTION) )
return EXIT_FAILURE;
#if BUILD_HTTPD
if (httpd_start()!=ERROR_OK)
return EXIT_FAILURE;
#endif
if (ret != ERROR_COMMAND_CLOSE_CONNECTION)
{
command_context_mode(cmd_ctx, COMMAND_EXEC);
if (command_run_line(cmd_ctx, "init")!=ERROR_OK)
return EXIT_FAILURE;
/* handle network connections */
server_loop(cmd_ctx);
}
/* shut server down */
server_quit();
#if BUILD_HTTPD
httpd_stop();
#endif
unregister_all_commands(cmd_ctx);
/* free commandline interface */
command_done(cmd_ctx);
return EXIT_SUCCESS;
}
int main(void)
{
SetConsoleTitle(TITLE);
mtx_init(&gmutex, mtx_plain);
cnd_init(&gcond);
init_timer();
init_path();
init_strings();
init_server();
initpackets();
//test_map(1);
thrd_create(&t1, initsocket, (void*)0);
thrd_create(&t2, commands, (void*)0);
server_loop();
destroy_server();
mtx_destroy(&gmutex);
cnd_destroy(&gcond);
#if _DEBUG
VLDReportLeaks();
#endif
exit(TRUE);// Exit program
}
int main(int ac, char **av)
{
t_args option;
if (ac < 5)
return (usage(av[0]));
signal(SIGINT, &signal_handler);
signal(SIGPIPE, SIG_IGN);
srand(time(NULL) + getpid());
init_args(&option);
if (check_args(ac, av, &option) == false
|| check_all_args(&option) == false)
return (usage(av[0]));
display_init(&option);
g_s.global_time = 0;
g_s.id_egg = 1;
g_s.other_size = 0;
if ((g_s.sock = init_server(option.port)) == -1)
return (display_error("Error : Could not init the server.\n"));
printf("**** Initialization done\n");
init_map(&g_s, option.width, option.height);
init_team(&g_s, option.nb_client, option.team_name);
init_stone(&g_s, option.width * option.height);
g_s.option = &option;
server_loop(&g_s);
xclose(g_s.sock);
return (0);
}
int main(int argc, char** argv)
{
int i;
if (argc < 2) {
fprintf(stderr, "usage: ./server <port> \n");
return -1;
}
struct addrinfo hint, *res = NULL;
hint.ai_family = AF_INET;
hint.ai_flags = AI_PASSIVE;
hint.ai_protocol = IPPROTO_UDP;
hint.ai_socktype = SOCK_DGRAM;
int ret = getaddrinfo("0.0.0.0", argv[1], &hint, &res);
if (ret != 0) {
fprintf(stderr, "getaddrinfo error: %s\n", gai_strerror(ret));
return -2;
}
int s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (s < 0) {
perror("socket");
return -3;
}
if (bind(s, res->ai_addr, res->ai_addrlen) < 0) {
perror("bind");
return -4;
}
freeaddrinfo(res);
return server_loop(s);
}
void lobby_host_loop() {
struct proto_join_packet packet;
static int tick = 0;
DARNIT_KEYS keys;
keys = d_keys_get();
d_keys_set(keys);
d_render_tile_blit(config.menu_background, 0, 0, 0);
if(!tick) {
packet.type = PROTO_TYPE_JOIN;
packet.player_id = -1;
strcpy(packet.player_name, config.player_name);
network_send(config.server.addr, &packet, sizeof(struct proto_join_packet));
update_player_list(lobby_join.list_players, config.player.player);
}
server_loop();
if(keys.select) {
game_state(GAME_STATE_LOBBY);
}
if(keys.start) {
game_state(GAME_STATE_GAME);
}
d_text_surface_draw(lobby_join.list_players);
d_text_surface_draw(lobby_host.start_game);
tick++;
tick %= 3;
}
int main(int argc, const char *argv[])
{
int opt;
poptContext pc;
struct main_context *main_ctx;
int ret;
uid_t uid;
gid_t gid;
struct poptOption long_options[] = {
POPT_AUTOHELP
SSSD_MAIN_OPTS
SSSD_SERVER_OPTS(uid, gid)
POPT_TABLEEND
};
/* Set debug level to invalid value so we can decide if -d 0 was used. */
debug_level = SSSDBG_INVALID;
umask(DFL_RSP_UMASK);
pc = poptGetContext(argv[0], argc, argv, long_options, 0);
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
poptFreeContext(pc);
DEBUG_INIT(debug_level);
/* set up things like debug, signals, daemonization, etc... */
debug_log_file = "sssd_pac";
ret = server_setup("sssd[pac]", 0, uid, gid,
CONFDB_PAC_CONF_ENTRY, &main_ctx);
if (ret != EOK) return 2;
ret = die_if_parent_died();
if (ret != EOK) {
/* This is not fatal, don't return */
DEBUG(SSSDBG_OP_FAILURE, "Could not set up to exit when parent process does\n");
}
ret = pac_process_init(main_ctx,
main_ctx->event_ctx,
main_ctx->confdb_ctx);
if (ret != EOK) return 3;
/* loop on main */
server_loop(main_ctx);
return 0;
}
int main(int argc, char **argv) {
server_t srv = server_init("0.0.0.0", 5431, test_onmessage, test_onconnect, test_ondisconnect);
if (!server_start(srv)) {
return EXIT_FAILURE;
}
server_loop(srv);
return EXIT_SUCCESS;
}
int loop(void){
int i;
int status = 0;
struct emwin_server *es;
es = get_next_server();
if(es == NULL){
status = 1;
log_errx("No servers available.");
log_info("Waiting %d seconds.", g.retrysleep);
for(i = 0; i <= g.retrysleep; ++i){
sleep(1);
if(get_quit_flag() != 0)
break;
}
log_info("Trying server list again.");
}else if(es->fd == -1){
if(es->gai_code != 0){
log_errx("Cannot open connection to %s. %s", es->ip,
gai_strerror(es->gai_code));
}else{
log_err2("Cannot open connection to", es->ip);
}
status = 1;
}else if(es->fd == -2){
if(server_type_serial_device(es))
log_errx("Cannot configure or synchronize %s:%s", es->ip, es->port);
else
log_errx("Could not get packet from %s", es->ip);
status = 1;
}else{
log_info("Connected to %s @ %s", es->ip, es->port);
}
while((status == 0) && (get_quit_flag() == 0)){
if(g.f_server_enabled == 1)
server_loop();
status = process_packets(es);
periodic();
if(get_reload_servers_list_flag())
reload_servers_list();
if(get_send_bbclientid_flag())
bb_send_clientid(es);
}
if(get_quit_flag() != 0)
log_info("Closing processor.");
return(status);
}
/**
* test_server_loop() 関数テスト
*
* @return なし
*/
void
test_server_loop(void)
{
pid_t cpid = 0; /* 子プロセスID */
pid_t w = 0; /* wait戻り値 */
int status = 0; /* wait引数 */
int retval = 0; /* 戻り値 */
int count = 1; /* ループカウント */
if (set_port_string(port) < 0)
cut_error("set_port_string");
ssock = server_sock();
cpid = fork();
if (cpid < 0) {
cut_error("fork(%d)", errno);
return;
}
if (cpid == 0) {
dbglog("child");
count = 2;
g_sig_handled = 1;
while (count--)
server_loop(ssock);
exit(EXIT_SUCCESS);
} else {
dbglog("parent: cpid=%d", (int)cpid);
csock = inet_sock_client();
if (csock < 0)
return;
/* 送信 */
retval = send_client(csock, expr, sizeof(expr));
if (retval < 0) {
cut_error("send_client: csock=%d(%d)", csock, errno);
return;
}
/* 受信 */
retval = recv_client(csock, readbuf);
if (retval < 0) {
cut_error("recv_client: csock=%d(%d)", csock, errno);
return;
}
cut_assert_equal_string((char *)expected, (char *)readbuf);
w = wait(&status);
if (w < 0)
cut_notify("wait(%d)", errno);
dbglog("w=%d", (int)w);
}
}
int main(int argc, char* argv[])
{
#if defined(WIN32) || defined(__WIN32__)
{
char buff[1024];
if (WSAStartup(0x0202,(WSADATA *) &buff[0])){
if(verbose){
handle_error(__FILE__, __LINE__);
}
return -1;
}
}
init(argc, argv);
init_master(&master);
InitializeCriticalSection(&master.lock);
logging_name = "FWT Proxy";
server_loop(
&client_handler, &get_client_data, &get_addr, buf, sock_data,
listen_port, &hello, &master, &timer_event
);
return 0;
#endif
#if !defined(WIN32) && !defined(__WIN32__)
init(argc, argv);
init_master(&master);
logging_name = "FWT Proxy";
server_loop(
&client_handler, &get_client_data, &get_addr, buf, sock_data,
listen_port, &hello, &master, &timer_event
);
return 0;
#endif
}
int main (int argc, char * argv[]) {
if (argc != 2) {
printf("%s", HELP);
exit(-1);
}
int port = strtol(argv[1], NULL, 10);
server_loop(port);
return 0;
}
int server()
{
int fd;
struct sockaddr_un sun;
/* Setup for abstract unix socket */
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
sun.sun_path[0] = 0;
sprintf(sun.sun_path+1, "ifstat%dv" VERSION, getuid());
if (conf.scan_interval == 0)
conf.scan_interval = DEFAULT_INTERVAL;
if (conf.time_constant == 0)
conf.time_constant = DEFAULT_TIME_CONST;
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
perror("ifstat: socket");
return -1;
}
if (bind(fd, (struct sockaddr*)&sun, sizeof(sun)) < 0) {
perror("ifstat: bind");
return -1;
}
if (listen(fd, 5) < 0) {
perror("ifstat: listen");
return -1;
}
if(!conf.foreground) {
if (fork()) {
/* parent */
close(fd);
/* clear settings, already used by daemon */
conf.time_constant = conf.scan_interval = 0;
return 0;
}
}
conf.time_constant *= 1000;
conf.scan_interval *= 1000;
W = 1 - 1/exp(log(10)*(double)conf.scan_interval/conf.time_constant);
chdir("/");
if(!conf.foreground) {
close(0); close(1); close(2);
setsid();
}
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, sigchild);
server_loop(fd);
exit(0);
}
int main(int argc, char *argv[]) {
/* TODO install signalhandler clean_up for clean termination */
set_up_server();
print_ip_and_port(); /* inform user of where we are running */
server_loop();
}
int main()
{
/*Create a listening BSD server socket*/
serv_sock = register_server();
server_loop(serv_sock);
close(serv_sock);
return 0;
}
int
main()
{
int sd;
struct sockaddr_in laddr;
pid_t pid;
int i, val;
sd = socket(AF_INET, SOCK_STREAM, 0 /* IPPROTO_TCP, IPPROTO_SCTP */);
if (sd<0) {
perror("socket()");
exit(1);
}
val = 1;
if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val))<0) {
perror("setsockopt(..., SO_REUSEADDR, ...)");
}
laddr.sin_family = AF_INET;
laddr.sin_port = htons(atoi(SERVERPORT));
inet_pton(AF_INET, "0.0.0.0", &laddr.sin_addr);
if (bind(sd, (void*)&laddr, sizeof(laddr))<0) {
perror("bind()");
exit(1);
}
if (listen(sd, 200)<0) {
perror("listen()");
exit(1);
}
for (i=0; i<POOLSIZE; ++i) {
pid = fork();
if (pid<0) {
perror("fork");
exit(1);
}
if (pid==0) {
server_loop(sd);
exit(0);
}
}
for (i=0; i<POOLSIZE; ++i) {
wait(NULL);
}
close(sd);
return 0;
}
/**
* @brief Bootloader "C" entry point
*
* @param none
*
* @returns Nothing. Will launch/restart image if successful, halt if not.
*/
void bootrom_main(void) {
chip_init();
dbginit();
dbgprint("gbboot Server\n");
chip_wait_for_link_up();
while(1) {
server_loop();
}
}
int
main(int argc, char *argv[]) {
server_type_t server_type;
int port;
read_args(argc, argv, &port, &server_type);
server_t *server = server_new(server_type, port);
server_set_accept_callback(server, on_client_accepted);
server_set_data_callback(server, on_incoming_data);
server_set_close_callback(server, on_client_closed);
server_loop(server);
server_destroy(server);
return 0;
}
int
main(int argc, char **argv) {
assert(((api_msg*)(0))->msg == (void *)API_MSG_HDR_SZ);
atexit(on_server_exit);
server_setup();
memset(&s, 0, sizeof(s));
create_srv_dsock(&s);
(void) signal(SIGINT, on_interrupt);
server_loop();
return 0;
}
void start_server(int deamon)
{
//初始化全局变量
header_buffer = (char *) malloc(MAX_HEADER_SIZE);
signal(SIGCHLD, sigchld_handler); // 防止子进程变成僵尸进程
if ((server_sock = create_server_socket(local_port)) < 0)
{ // start server
LOG("Cannot run server on %d\n",local_port);
exit(server_sock);
}
if(deamon)
{
pid_t pid;
if((pid = fork()) == 0)
{
server_loop();
} else if (pid > 0 )
{
m_pid = pid;
LOG("mporxy pid is: [%d]\n",pid);
close(server_sock);
} else
{
LOG("Cannot daemonize\n");
exit(pid);
}
} else
{
server_loop();
}
}
int main(int argc, char **argv)
{
int sd;
int portnr;
int epmd_fd;
/* crate file descriptors */
if (init(&sd, &portnr, &epmd_fd) < 0)
return -1;
/* start server loop */
server_loop(sd,epmd_fd);
return 0;
}
/**
* Initializes the given socket structure
*
* \param data raw pointer to a \c DS_Socket structure
*/
static void* create_socket (void* data)
{
/* Data pointer is NULL */
if (!data)
return NULL;
/* Cast raw pointer to socket */
DS_Socket* ptr = (DS_Socket*) data;
/* Make the address 0.0.0.0 if it is empty */
if (DS_StringIsEmpty (ptr->address) || ptr->broadcast == 1) {
DS_FREESTR (ptr->address);
ptr->address = sdsnew ("0.0.0.0");
}
/* Set service strings */
ptr->info.in_service = itc (ptr->in_port);
ptr->info.out_service = itc (ptr->out_port);
/* Open TCP socket */
if (ptr->type == DS_SOCKET_TCP) {
ptr->info.sock_in = create_server_tcp (ptr->info.in_service,
SOCKY_IPv4, 0);
ptr->info.sock_out = create_client_tcp (ptr->address,
ptr->info.out_service,
SOCKY_IPv4, 0);
}
/* Open UDP socket */
else if (ptr->type == DS_SOCKET_UDP) {
ptr->info.sock_in = create_server_udp (ptr->info.in_service,
SOCKY_IPv4, 0);
ptr->info.sock_out = create_client_udp (SOCKY_IPv4, 0);
}
/* Update initialized states */
ptr->info.server_init = (ptr->info.sock_in > 0);
ptr->info.client_init = (ptr->info.sock_out > 0);
/* Start server loop */
server_loop (ptr);
/* Exit */
return NULL;
}
int main(int argc, char *argv[])
{
int pid = getppid();
/* Need to fork so stunnel doesn't kill us */
if (fork() == 0) {
/* Become session leader */
setsid();
/* Goodbye - thanks for the descriptor */
kill(pid, SIGUSR2);
close(0); close(1); close(2);
ssl_init();
server_loop(LISTEN_DESCRIPTOR);
}
return 0;
}
