int main()
{
//init win32 socket
#ifdef __WIN32__
static WSADATA wsa_data;
int result = WSAStartup((WORD)(1<<8|1), &wsa_data); //初始化WinSocket动态连接库
if( result != 0 ) // 初始化失败
return -1;
#endif
#ifndef __WIN32__
signal( SIGPIPE, SIG_IGN ); //ignore send,recv SIGPIPE error
#endif
NEW( websrv, sizeof(webserver) );
memset( websrv, 0, sizeof(webserver) );
server_create( websrv, "config.xml" );
server_start( websrv );
do_console();
server_stop( websrv );
server_end( websrv );
DEL( websrv );
#ifdef __WIN32__
WSACleanup();
#endif
memory_end();
return 0;
}
int main(int argv,char **args)
{
int ret,epfd,nfds,server_socket_fd,i,index;
struct epoll_event events[256];
int count;
server_socket_fd = server_start();
if(server_socket_fd<0)
{
return 0;
}
set_non_blocking(server_socket_fd);
epfd = epoll_create(1024);
set_non_blocking(epfd);
epoll_add(epfd,server_socket_fd);
struct http_request_r *r=NULL,*p=NULL;
while(1)
{
nfds=epoll_wait(epfd,events,20,500);
for(i=0;i<nfds;i++)
{
if(events[i].data.fd==server_socket_fd)
{
onAccept(epfd,events[i],&r);
}
else if(events[i].events&EPOLLIN)
{
onData(epfd,events[i],&r);
}
}
}
}
void
doit (void)
{
server_start ();
if (error_count)
return;
child = fork ();
if (child < 0)
{
perror ("fork");
fail ("fork");
return;
}
if (child)
{
int status;
/* parent */
server ();
wait (&status);
}
else
client ();
}
// ---------------------------------- main() --------------------------------
int main(int argc, char *argv[]) {
if (argc == 2) //if you input 2 arguments, then the first input becomes the port number
portno = atoi(argv[1]);
server_start();
return 0;
}
//read config file, and start to listen
void csiebox_server_init(/*{{{*/
csiebox_server** server, int argc, char** argv) {
csiebox_server* tmp = (csiebox_server*)malloc(sizeof(csiebox_server));
if (!tmp) {
fprintf(stderr, "server malloc fail\n");
return;
}
memset(tmp, 0, sizeof(csiebox_server));
if (!parse_arg(tmp, argc, argv)) {
fprintf(stderr, "Usage: %s [config file]\n", argv[0]);
free(tmp);
return;
}
int fd = server_start();
if (fd < 0) {
fprintf(stderr, "server fail\n");
free(tmp);
return;
}
tmp->client = (csiebox_client_info**)
malloc(sizeof(csiebox_client_info*) * getdtablesize());
if (!tmp->client) {
fprintf(stderr, "client list malloc fail\n");
close(fd);
free(tmp);
return;
}
memset(tmp->client, 0, sizeof(csiebox_client_info*) * getdtablesize());
tmp->listen_fd = fd;
*server = tmp;
}
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;
}
int main(int argc, char* argv[])
{
int id = 0;
if (argc >= 2)
{
id = atoi(argv[1]);
}
int i=0;
for (;i<argc; i++)
{
if (strcmp(argv[i], "-d") == 0)
{
init_daemon();
break;
}
}
server_start(id);
while (1)
{
sleep(60);
}
server_shutdown();
return 0;
}
int main(int argc, char *argv[]) {
server_setup_signals();
server_parse_params(argc, argv);
server_printopts();
server_start();
return 0;
}
/* Module functions */
static int
init(const struct mpdcron_config *conf, GKeyFile *fd)
{
GError *error;
g_debug("Initializing");
/* Load configuration */
if (file_load(conf, fd) < 0)
return MPDCRON_INIT_FAILURE;
/* Initialize database */
error = NULL;
if (!db_init(globalconf.dbpath, true, false, &error)) {
g_critical("Failed to initialize database `%s': %s",
globalconf.dbpath, error->message);
g_error_free(error);
file_cleanup();
return MPDCRON_INIT_FAILURE;
}
/* Initialize, bind and start the server */
server_init();
for (unsigned int i = 0; globalconf.addrs[i] != NULL; i++) {
if (strncmp(globalconf.addrs[i], "any", 4) == 0)
server_bind(NULL, globalconf.port);
else if (globalconf.addrs[i][0] == '/')
server_bind(globalconf.addrs[i], -1);
else
server_bind(globalconf.addrs[i], globalconf.port);
}
server_start();
timer = g_timer_new();
return MPDCRON_INIT_SUCCESS;
}
int hsn_node_setup(t_hsn_node *node,
const char *credentials_dirpath,
const char *peers_list_filepath,
const char *peers_dirpath,
int port)
{
fprintf(stderr, "HSN node setup:\n");
fprintf(stderr, "* Loading credentials...\n");
if (hsn_node_load_credentials(node, credentials_dirpath) != 0)
goto err_load_credentials;
fprintf(stderr, "* Loading peers...\n");
if (hsn_node_load_peers(node, peers_list_filepath, peers_dirpath) != 0)
goto err_load_peers;
fprintf(stderr, "* Connecting to peers...\n");
if (hsn_node_connect_to_peers(node) != 0)
goto err_connect_to_peers;
fprintf(stderr, "* Starting server...\n");
node->server.port = port;
if (server_start(node) != 0)
goto err_start_server;
fprintf(stderr, "done.\n\n");
return (0);
err_start_server:
hsn_node_disconnect_from_peers(node);
err_connect_to_peers:
hsn_node_unload_peers(node);
err_load_peers:
hsn_node_unload_credentials(node);
err_load_credentials:
return (1);
}
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;
}
void test()
{
server = epollserver_create(HTTP_PORT, MAX_CLIENT_NUM, 1024, 1024);
printf("EAGAIN is %d\n", EAGAIN);
printf("ECONNRESET is %d\n", ECONNRESET);
server_start(server, my_logic_on_enter_pt, my_logic_on_close_pt, my_logic_on_recved_pt);
}
char *test_server_start()
{
mu_assert("Starting server", server_start("::1","3141",1,&pid) == 0);
mu_assert("Ensure we have pid for daemon", pid > 0);
mu_assert("Verify pid is valid", kill(pid, 0) == 0);
return 0;
}
int main(int argc, char *argv[]) {
short port;
port = get_port(argc, argv);
server_start(port, (callback_t) &handle); /* infinite loop */
return EXIT_SUCCESS; /* to make gcc happy */
}
int main(int argc, char *argv[]) {
Server *server = create_server();
server->port = PORT;
server->handler = &handler;
server_start(server);
return 0;
}
int main(int argc, char const* argv[]) {
server_t* s;
sigset_t mask;
siginfo_t info;
struct sigaction action;
if(argc == 1) {
if(!server_create(&s, "../calories.csv", NULL)) {
if(!server_create(&s, "./calories.csv", NULL)) {
printf("File '%s' fot found\n", "calories.csv");
exit(1);
}
}
} else if(argc == 2) {
if(!server_create(&s, "../calories.csv", argv[1])) {
if(!server_create(&s, "./calories.csv", argv[1])) {
printf("File '%s' fot found\n", "calories.csv");
exit(1);
}
}
} else {
printf("%s\n", SERVER_MAIN_HELP);
exit(1);
}
printf("Press CTRL+C to shutdown the server\n");
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigprocmask(SIG_BLOCK, &mask, NULL);
sigemptyset(&action.sa_mask);
action.sa_flags = SA_SIGINFO;
sigaction(SIGCHLD, &action, NULL);
if(server_start(s)) {
while(true) {
// signal() is NOT thread safe!
// And since the server doesn't block signal handling is "not" needed ...
if(sigwaitinfo(&mask, &info) == -1) {
perror("sigwaitinfo() failed");
exit(1);
}
switch(info.si_signo) {
case SIGINT:
server_destroy(s);
return 0;
}
}
} else {
server_destroy(s);
}
}
static int hid_server_probe(struct btd_profile *p, struct btd_adapter *adapter)
{
int ret;
ret = server_start(adapter_get_address(adapter));
if (ret < 0)
return ret;
adapters = g_slist_append(adapters, btd_adapter_ref(adapter));
return 0;
}
void server_init()
{
servers = pmap_new(cstr_t)();
if (!os_getenv("NEOVIM_LISTEN_ADDRESS")) {
char *listen_address = (char *)vim_tempname('s');
os_setenv("NEOVIM_LISTEN_ADDRESS", listen_address, 1);
free(listen_address);
}
server_start((char *)os_getenv("NEOVIM_LISTEN_ADDRESS"));
}
/// Initializes the module
void server_init(void)
{
servers = pmap_new(cstr_t)();
if (!os_getenv(LISTEN_ADDRESS_ENV_VAR)) {
char *listen_address = (char *)vim_tempname();
os_setenv(LISTEN_ADDRESS_ENV_VAR, listen_address, 1);
free(listen_address);
}
server_start((char *)os_getenv(LISTEN_ADDRESS_ENV_VAR));
}
int main(int argc, char **argv)
{
if (argc > 1 && !strcmp(argv[1], "--server")) {
if (argc > 2 && !strcmp(argv[2], "--pc"))
server_start(PLAYER_PC);
else
server_start(PLAYER_HUMAN);
}
else if (argc > 1 && !strcmp(argv[1], "--client")) {
if (argc > 2 && !strcmp(argv[2], "--pc"))
client_start(PLAYER_PC);
else
client_start(PLAYER_HUMAN);
}
else {
printf("Usage:\n");
printf(" %s --server Start Server (Player 1)\n", argv[0]);
printf(" %s --client Start Client (Player 2)\n", argv[0]);
printf(" %s [......] --pc Start as PC Player\n", argv[0]);
}
return 0;
}
int main(int argc, char **argv)
{
enum start_mode mode = NONE;
while (1) {
int index, c;
c = getopt_long(argc, argv, short_options, long_options, &index);
if (c == -1)
break;
switch (c) {
case 0:
break;
case 'd':
debug = 1;
break;
case 'm':
if (strcmp(optarg, "server") == 0)
mode = SERVER;
else if (strcmp(optarg, "client") == 0)
mode = CLIENT;
break;
case 'h':
usage(stdout, argv);
exit(EXIT_SUCCESS);
default:
usage(stderr, argv);
exit(EXIT_FAILURE);
}
}
switch (mode) {
case CLIENT:
client_start();
break;
case SERVER:
server_start();
break;
case NONE:
usage(stderr, argv);
exit(EXIT_FAILURE);
}
return 0;
}
/* Test grpc_fd. Start an upload server and client, upload a stream of
bytes from the client to the server, and verify that the total number of
sent bytes is equal to the total number of received bytes. */
static void test_grpc_fd(void) {
server sv;
client cl;
int port;
server_init(&sv);
port = server_start(&sv);
client_init(&cl);
client_start(&cl, port);
client_wait_and_shutdown(&cl);
server_wait_and_shutdown(&sv);
GPR_ASSERT(sv.read_bytes_total == cl.write_bytes_total);
gpr_log(GPR_INFO, "Total read bytes %d", sv.read_bytes_total);
}
static int hid_server_probe(struct btd_adapter *adapter)
{
bdaddr_t src;
int ret;
adapter_get_address(adapter, &src);
ret = server_start(&src);
if (ret < 0)
return ret;
adapters = g_slist_append(adapters, btd_adapter_ref(adapter));
return 0;
}
//int main(int argc, char *argv[], char *envp[])
int main(int argc, char *argv[])
{
puts("Starting morrigan.");
unsigned short port = 0;
if (1 < argc)
{
port = (unsigned short) atoi(argv[1]);
if (!port)
{
port = PORT;
}
printf("Using port: %d.\n", port);
}
check(SIG_ERR != signal(SIGINT, __stop), "Failed to set signal handler.", "");
check(SIG_ERR != signal(SIGTERM, __stop), "Failed to set signal handler.", "");
srand((unsigned) (time(NULL) ^ _getpid()));
l = landscape_load("land.dat", 32, 1.0);
check(l, "Failed to load landscape.", "");
check(net_start(port), "Failed to start network interface.", "");
check(server_start(), "Failed to start server.", "");
check(game_start(l, server_get_clients()), "Failed to start game.", "");
do
{
printf(">");
input = bgets(fgetc, stdin, '\n');
if (NULL == input || 0 == strcmp("exit\n", bdata(input)))
{
break;
}
bdestroy(input);
input = NULL;
} while(true);
__stop(0);
return EXIT_SUCCESS;
error:
fprintf(stderr, "Error exit.\n");
__stop(0);
return EXIT_FAILURE;
}
int main(int argc, char *argv[]) {
#ifdef SIGHUP
signal(SIGHUP,signal_handler);
#endif
if ( command_line_parameters(argc, argv) != 0 ) {
exit(EXIT_FAILURE);
}
s = server_new(cfg_file);
server_start(s);
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
uv_loop_t* loop;
loop = uv_default_loop();
server_initialize(loop, &_server);
server_start(&_server);
fprintf(stderr, "socket-server starts...\n");
uv_run(loop);
server_destroy(&_server);
return 0;
}
/* Test grpc_fd. Start an upload server and client, upload a stream of
bytes from the client to the server, and verify that the total number of
sent bytes is equal to the total number of received bytes. */
static void test_grpc_fd(void) {
server sv;
client cl;
int port;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
server_init(&sv);
port = server_start(&exec_ctx, &sv);
client_init(&cl);
client_start(&exec_ctx, &cl, port);
grpc_exec_ctx_finish(&exec_ctx);
client_wait_and_shutdown(&cl);
server_wait_and_shutdown(&sv);
GPR_ASSERT(sv.read_bytes_total == cl.write_bytes_total);
gpr_log(GPR_INFO, "Total read bytes %" PRIdPTR, sv.read_bytes_total);
}
int
main(int argc, char *argv[]) {
const char * config_file = NULL ;
if (argc > 1) {
config_file = argv[1];
} else {
fprintf(stderr, "Need a config file.\n");
return 1;
}
server_globalinit();
server_env_init();
sigign();
server_pid = (int)getpid();
struct server_config config;
struct lua_State *L = lua_newstate(server_lalloc, NULL);
luaL_openlibs(L);
int r = luaL_loadfile(L, config_file);
if (r) {
fprintf(stderr,"luaL_loadfile err:%s\n",lua_tostring(L,-1));
lua_close(L);
return 1;
}
int err = lua_pcall(L,0,1,0);
if (err) {
fprintf(stderr,"lua_pcall config file err:%s\n",lua_tostring(L,-1));
lua_close(L);
return 1;
}
_init_env(L);
config.harbor = optint("harbor", 1);
config.thread = optint("thread",8);
config.logger = optstring("logger", NULL);
config.bootstrap = optstring("bootstrap","snlua bootstrap");
config.module_path = optstring("cpath","./cservice/?.so");
lua_close(L);
//启动服务
server_start(&config);
return 0;
}
/// Initializes the module
bool server_init(void)
{
ga_init(&servers, sizeof(Server *), 1);
bool must_free = false;
const char *listen_address = os_getenv(LISTEN_ADDRESS_ENV_VAR);
if (listen_address == NULL) {
must_free = true;
listen_address = (char *)vim_tempname();
}
bool ok = (server_start(listen_address) == 0);
if (must_free) {
xfree((char *) listen_address);
}
return ok;
}
int
server_init (int argc, char *argv[])
{
int retval;
char *port = STD_PORT, *hostname = STD_HOSTNAME;
while ((retval = getopt(argc, argv, "dn:hH:P:c:")) != -1) {
switch (retval) {
case 'c':
max_cycles = atoi(optarg);
break;
case 'H':
hostname = optarg;
break;
case 'P':
port = optarg;
break;
case 'd':
debug = 1;
break;
case 'n':
max_robots = atoi(optarg);
break;
case 'h':
usage(argv[0], EXIT_SUCCESS);
break;
default:
break;
}
}
if (argc > optind) /* || !hostname || !port)*/
usage(argv[0], EXIT_FAILURE);
if (max_robots <= 1)
max_robots = STD_CLIENTS;
if (max_cycles <= 1)
max_cycles = STD_CYCLES;
all_robots = (struct robot **) malloc(max_robots * sizeof(struct robot *));
server_start(hostname, port);
return 0;
}
