static int speedtest(int dl_enable, int ul_enable) { int i; client_config_t client; server_config_t servers[CLOSEST_SERVERS_NUM]; server_config_t best_server; for (i = 0; i < CLOSEST_SERVERS_NUM; i++) { init_server(&servers[i]); } init_server(&best_server); init_client(&client); if (get_speedtest_config(&client)) { fprintf(stderr, "get_speedtest_config error!\n"); nvram_set("speedtest_running", "2"); return -1; } if (get_nearest_servers(&client, servers)) { fprintf(stderr, "get_nearest_servers error!\n"); nvram_set("speedtest_running", "2"); return -1; } client_free(&client); if (get_lowest_latency_server(servers, &best_server)) { fprintf(stderr, "get_lowest_latency_server error!\n"); nvram_set("speedtest_running", "2"); return -1; } if (dl_enable == 1) { if (test_download_speed(&best_server)) { fprintf(stderr, "test_download_speed error!\n"); nvram_set("speedtest_running", "2"); return -1; } } if (ul_enable == 1) { finished = (double)0; if (test_upload_speed(&best_server)) { fprintf(stderr, "test_upload_speed error!\n"); nvram_set("speedtest_running", "2"); return -1; } } for (i = 0; i < CLOSEST_SERVERS_NUM; i++) { server_free(&servers[i]); } nvram_set("speedtest_running", "1"); nvram_commit(); return 0; }
int main(int argc, char *argv[]) { char **p_ptr = NULL; char *config_file = NULL; int port = GAMED_PORT; int c, fork = 1; long requested_port = 0; struct rlimit limit; while ((c = getopt (argc, argv, "Xp:f:")) != -1) { switch(c) { case 'X': fork = 0; break; case 'p': requested_port = strtol(optarg, p_ptr, 10); if (p_ptr != NULL || requested_port > 65535) { printf("%s is not a valid port\n", optarg); return 1; } port = requested_port; break; case 'f': case '?': if (optopt == 'p') { /* getopt is printing errors for me, so this isn't needed fprintf(stderr, "No port specified with -p\n"); */ } else { fprintf(stderr, "Usage: [-X] [-p port] [-f /path/to/config]\n"); } return 1; default: abort(); } } limit.rlim_cur = RLIM_INFINITY; limit.rlim_max = RLIM_INFINITY; setrlimit(RLIMIT_CORE, &limit); if (fork) { if (daemon(1, 0) == -1) { perror("daemonize"); return 1; } } if (config_file == NULL) { init_server(port, DEFAULT_CONFIG); } else { init_server(port, config_file); } free(config_file); run_server(); return 0; }
int main(int argc, const char * argv[]) { init_server(); void* received = malloc(2048); time_t send_hb_time = time(0); time_t check_hb_time = time(0); while(1){ receive_msg(received, _size(MSG_LOGIN), LOGIN, &handle_login); receive_msg(received, _size(MSG_LOGIN), LOGOUT, &handle_logout); receive_msg(received, _size(MSG_REQUEST), REQUEST, &handle_request); receive_msg(received, _size(MSG_CHAT_MESSAGE), MESSAGE, &handle_message); receive_msg(received, _size(MSG_ROOM), ROOM, &handle_room_action); receive_msg(received, _size(MSG_SERVER2SERVER), SERVER2SERVER, &handle_server_heartbeat); if (time(0) - send_hb_time > 2) { send_hb_time = time(0); send_heartbeats_to_clients(); } if (time(0) - check_hb_time > 2) { check_hb_time = time(0); check_heartbeat_table(); } usleep(100); } free(received); clean(); return 0; }
int init_program() { init_global_variable(); // read setting file to get id and ip mapping list. int numberofnode; ID_IP = read_setting_file(setting_file,&numberofnode); if(ID_IP == NULL) { printf("\nCannot read setting file"); exit(1); } // init server server_id = get_id_server(); char *ip_server = look_up_ip(ID_IP,server_id); printf("\nInit server :%s",ip_server); server_sd = init_server(ip_server,SERVER_PORT); //connect to neighbor // client_sd = reconnect_to_neighbor(server_id,ID_IP); ST = init_list_of_file(directory); return 1; }
int arm_open_server(int *socket, struct sockaddr_in *address, int src_port) { // Init circular buffer arm_buffer_tx_ptr_wr = 0; arm_buffer_tx_ptr_rd = 0; arm_buffer_tx_empty = 1; arm_buffer_tx_full = 0; arm_buffer_tx_overrun = 0; arm_buffer_tx_data_count = 0; arm_buffer_rx_ptr_wr = 0; arm_buffer_rx_ptr_rd = 0; arm_buffer_rx_empty = 1; arm_buffer_rx_full = 0; arm_buffer_rx_overrun = 0; arm_buffer_rx_data_count = 0; if(init_server(socket, address, src_port) == -1) return 0; else { arm_net_down = 0; return 1; } }
int main(int argc, char **argv) { struct sigaction actions; parse_options(&argc, &argv); if (asprintf(&libmemtrace, "%s/libmemtrace.so", lib_path) == -1) fatal("asprintf (%s)", strerror(errno)); create_shmem(); main_pid = app_start((char **)(argv + 1)); atexit(cleanup); signal(SIGINT, sigint_handler); sigemptyset(&actions.sa_mask); actions.sa_flags = SA_RESTART; actions.sa_handler = sigchld_handler; if (sigaction(SIGCHLD, &actions, NULL)) { perror("sigaction(SIGCHLD)"); return 1; } create_socket(); create_comm(); init_server(); server_run(); return EXIT_SUCCESS; }
static void server(int sock) { char buff[BUF_SIZE + 1]; int actual; t_server server; actual = 0; init_server(&server, sock); while (1) { init_fds(&server, actual); if (select(server.max + 1, &server.rdfs, NULL, NULL, NULL) == -1) exit_error("select"); if (FD_ISSET(STDIN_FILENO, &server.rdfs)) break ; else if (FD_ISSET(server.sock, &server.rdfs)) { if (new_client(&server, &actual, buff) == -1) continue ; } else client_talking(&server, &actual, buff); } clear_clients(server.clients, actual); close(server.sock); }
int main(int argc, char ** argv) { struct sigaction sa; serialport = open(SERIALDEVICE, O_RDWR | O_NOCTTY); if (serialport < 0) { perror(SERIALDEVICE); exit(EXIT_FAILURE); } init_serial(serialport); send_init_commands(serialport); // Signal handler sa.sa_handler = shutdown_server; sigemptyset(&sa.sa_mask); if (sigaction(SIGINT, &sa, NULL) == -1) { exit(EXIT_FAILURE); } init_server(); fprintf(stderr, "Ready to serve\n"); get_server_data_loop(&on_socket_data); fprintf(stderr, "Shutting down\n"); send_shutdown_command(serialport); close(serialport); exit(EXIT_SUCCESS); }
int main(int argc, const char *argv[]) { // Read arguments from "config.cfg" file and printing them int port; int max_clients; if(get_config(&port, &max_clients)) return(-1); // Main int srv_fd = -1; int epoll_fd = -1; reactor* r = 0; event_handler* seh = 0; if (init_server(&srv_fd, &epoll_fd, port, max_clients) != 0) return 1; r = create_reactor(epoll_fd, max_clients); seh = create_acceptor(srv_fd, r); r->add_eh(r, seh); r->event_loop(r); return 0; }
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){ char *msg; init_server(); while(1){ printf("%s%s", username, ": "); msg = input(); if(strlen(msg) == 0){ setmsg("\n"); } else if(strcmp(msg,"/exit") == 0){ free(msg); killout(); pthread_exit(&retm); }else{ char *newline = "\n"; msg = addchar(msg, newline); setmsg(msg); pthread_t tid; pthread_create(&tid, NULL, sendmesgptr, NULL); pthread_join(tid, NULL); } free(msg); } killout(); killinc(); }
int main(int argc, const char *argv[]) { int listen_fd, new_fd; listen_fd = init_server(); // init server, listen while (true) { new_fd = accept_client(listen_fd); if (new_fd == -1) { perror("accept"); continue; } /* * if accepted, fork() */ if (!fork()) { // this is the child process close(listen_fd); // child doesn't need the listener if (send(new_fd, "Hello, world!", 13, 0) == -1) perror("send"); bind_file(new_fd); start_service(); close_connection(); close(new_fd); exit(0); } close(new_fd); } return 0; }
int start_sdp_server(uint16_t mtu, uint32_t flags) { int compat = flags & SDP_SERVER_COMPAT; int master = flags & SDP_SERVER_MASTER; GIOChannel *io; info("Starting SDP server"); if (init_server(mtu, master, compat) < 0) { error("Server initialization failed"); return -1; } io = g_io_channel_unix_new(l2cap_sock); g_io_channel_set_close_on_unref(io, TRUE); l2cap_id = g_io_add_watch(io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, io_accept_event, &l2cap_sock); g_io_channel_unref(io); if (compat && unix_sock > fileno(stderr)) { io = g_io_channel_unix_new(unix_sock); g_io_channel_set_close_on_unref(io, TRUE); unix_id = g_io_add_watch(io, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, io_accept_event, &unix_sock); g_io_channel_unref(io); } return 0; }
int start_ui_handler(pthread_t *tid, struct agent_list *agent_list, const char *sock_file) { struct sockaddr_un addr; int addr_len; if (unlink(sock_file) && errno != ENOENT) { ERROR("can't unlink %s: %m", sock_file); return -1; } addr_len = set_sockaddr_un(&addr, sock_file); if (addr_len < 0) { ERROR("set_sockaddr_un() failed: %m"); return -1; } sock = init_server(SOCK_STREAM, (struct sockaddr *) &addr, (socklen_t) addr_len, BACKLOG_SIZE); if (sock < 0) { ERROR("can't listen on %s: %m", sock_file); return -1; } list = agent_list; if (pthread_create(tid, NULL, accept_ui, NULL)) { close(sock); ERROR("can't create a thread: %m"); return -1; } return 0; }
int rfind_server_start() { int fd = connect_to("localhost", default_register_port); if (fd < 0) { fprintf(stderr, "socket open error\n"); return -1; } int reg; char* name = getenv("USER"); char buf[protocol_buf_size]; sprintf(buf, "0%s", name); if (write(fd, buf, strlen(buf)) < 0) { fprintf(stderr, "register error\n"); close(fd); return -1; } if (read(fd, ®, sizeof(int)) < 0) { fprintf(stderr, "register error\n"); close(fd); return -1; } close(fd); if (reg == -1) { fprintf(stderr, "register fail\n"); return -1; } fprintf(stderr, "assigned port: %d\n", reg); return init_server(reg); }
PyMODINIT_FUNC init_dismage(void) #endif { PyObject *m; #ifdef PY3 m = PyModule_Create(&dismage_module_def); #else m = Py_InitModule3(MODULE_NAME, dismage_methods, ""); #endif if (m == NULL){ INITERROR; } if (init_server() < 0){ INITERROR; } add_drizzle_constants(m); database_error = PyErr_NewException("_dismage.DatabaseError", PyExc_IOError, NULL); if (database_error == NULL) { INITERROR; } Py_INCREF(database_error); PyModule_AddObject(m, "DatabaseError", database_error); #ifdef PY3 return m; #endif }
int main(int argc, char* argv[]) { signal(SIGINT, sigint); if(argc > 1) args_handle(argc, argv); if(client_host_addr != NULL) { int highscore_sd = connect_to_server(); if(highscore_sd == -1) { perror("Error connecting to the highscoreserver.\n"); return -1; }else{ set_client_socket_descriptor(highscore_sd); } } while(1) { init_server(); listen_for_connections(); game_over(); } return 0; }
int main(int argc, char **argv) { pthread_t *io_channel; pthread_t adv; int fds[16]; const int io_chans = 16; struct sockaddr_l2 addr; socklen_t qlen = sizeof(addr); socklen_t len = sizeof(addr); int l2cap_sock; int i; pthread_create(&adv, NULL, advertiser, NULL); l2cap_sock = init_server(652); if (l2cap_sock < 0) return EXIT_FAILURE; io_channel = malloc(io_chans * sizeof(*io_channel)); if (!io_channel) return EXIT_FAILURE; for (i = 0; i < io_chans; i++) { printf("%s: Going to accept on io chan %d\n", __func__, i); fds[i] = accept(l2cap_sock, (struct sockaddr *) &addr, &len); if (fds[i] < 0) { i--; printf("%s: Accept failed with %s\n", __func__, strerror(errno)); continue; } printf("%s: accepted\n", __func__); pthread_create(&io_channel[i], NULL, l2cap_data_thread, &fds[i]); } }
int CM2PM_server_start(PORT_NUM serv_port) { int listenfd = 0, connfd = 0; int action_label; listenfd = init_socket(); if (listenfd < 0) return -1; if (init_server(serv_port, listenfd) < 0) return -1; while (TRUE) { connfd = accept_request(listenfd); if (read_data(connfd, &action_label, sizeof(action_label)) < 0) { printf("Read Data Error\n"); return -1; } do_action(action_label); close(connfd); } //Success return 0; }
int main(int argc, char * argv[]) { int listenfd; int num; int i; if (argc < 2) { print_usage(); } num = atoi(argv[1]); idle_num = num; fprintf(stdout, "%d Channels are running ... \n", num); //to lock the log file lock_init(LOG_LOCK); listenfd = init_server(); pids = (pid_t *)(malloc(sizeof(pid_t) * num)); for (i = 0; i < num; i++) { pids[i] = child_make(i, listenfd); } signal_wrapper(SIGINT, sig_int); close_wrapper(listenfd); while(true) pause(); return 0; }
// // argv[1] should contain one of the role: server or client. // int main(int argc, const char * argv[]) { role_t role = RoleUnknown; if (argc>1) { if ( strcmp(argv[1], SERVER_ROLE_ARG)==0 ) { role = RoleServer; } else if ( strcmp(argv[1], CLIENT_ROLE_ARG)==0 ) { role = RoleClient; } else { printf("Unknown role. The role must be either 'server' or 'client'\n"); return EXIT_FAILURE; } } else { printf("You have to specify a role (server or client)\n"); return EXIT_FAILURE; } if (role == RoleClient) { printf("Start client\n"); init_client(); } else if (role == RoleServer) { printf("Start server\n"); init_server(); } return EXIT_SUCCESS; }
int obex_server_init(void) { GSList *drivers; GSList *transports; GSList *l; drivers = obex_service_driver_list(0); if (drivers == NULL) { DBG("No service driver registered"); return -EINVAL; } transports = obex_transport_driver_list(); if (transports == NULL) { DBG("No transport driver registered"); return -EINVAL; } for (l = drivers; l; l = l->next) { struct obex_service_driver *driver = l->data; init_server(driver->service, transports); } return 0; }
void handle_signal(int sig){ switch (sig){ case SIGUSR1: case SIGUSR2: syslog(LOG_DEBUG, "recieved SIGUSR %d", sig); if (kill_server() < 0) { syslog(LOG_CRIT,"SIGHANDLER: unable to kill server"); break; } if (kill_index() < 0) { syslog(LOG_CRIT,"SIGHANDLER: unable to kill index"); break; } if (init_index() < 0) { syslog(LOG_CRIT,"SIGHANDLER: unable to init index - index STILL down"); break; } if (init_server(main_ctx) < 0) { syslog(LOG_CRIT,"SIGHANDLER, unable to init server - index up but unknown by main server"); break; } break; case SIGHUP: case SIGTERM: syslog(LOG_DEBUG, "recieved SIGTERM %d", sig); if (kill_server() < 0) syslog(LOG_CRIT,"SIGHANDLER: unable to kill server"); if (kill_index() < 0) syslog(LOG_CRIT,"SIGHANDLER: unable to kill index"); kill_process(); /* should this be called ??? */ /* if called, must close sockets in threads */ /* before calling */ /* zmq_term(main_ctx); */ exit(0); } }
int do_server(int port, int *ret, int (*cb)(), char *context) { int sock; char *name; int accept_socket; int i; if (!init_server(&accept_socket,port)) return(0); if (ret != NULL) { *ret=accept_socket; /* return(1);*/ } for (;;) { if (do_accept(accept_socket,&sock,&name) == 0) { SHUTDOWN(accept_socket); return(0); } i=(*cb)(name,sock, context); if (name != NULL) OPENSSL_free(name); SHUTDOWN2(sock); if (i < 0) { SHUTDOWN2(accept_socket); return(i); } } }
int parse_server(t_info *inf, char **tab, int *i) { int j; int res; t_pt_funct_parse pt[5]; int done; done = 0; get_ptr_server(pt); if (tab[*i] && !my_strcmp("--server", tab[*i])) { init_server(inf); (*i)++; while (!done && tab[*i]) { j = -1; while (++j < 5) { if ((res = pt[j](inf, tab, i)) == -1) return (-1); j = (res) ? (5) : (j); } done = (res == 0 && j == 5) ? (1) : (0); } return ((!tab[*i]) ? (1) : (-1)); } return (0); }
int main(int argc, char *argv[]) { int opt; struct option longopts[] = { {"initialize", 0, NULL, 'i'}, {"help", 0, NULL, 'h'}, {"list", 0, NULL, 'l'}, {"restart", 0, NULL, 'r'}, {0,0,0,0} }; #if 0 while((opt = getopt(argc, argv, ":if:lr:h")) != -1) { switch(opt) { case 'i': case 'h': case 'r': printf("option: %c\n", opt); break; case 'f': printf("filename: %s\n", optarg); break; case ':': printf("option needs a value\n"); break; case '?': printf("unknown option: %c\n", optopt); break; } } for(; optind < argc; optind++) printf("argument: %s\n", argv[optind]); #endif do { get_help(); switch(opt) { case 1: init_server(); break; case 2: init_sla_support(); break; case 3: init_client(); break; default: printf("Oops you might pressed '%d' ", opt ); } } while(opt != 0); while(1) { sleep(1000); } }
int main(int argc, char *argv[]) { signal(SIGINT, on_sigint); if (init_server(&srv) == 0) serve(&srv); destroy_server(&srv); return 0; }
int main(int argc, char ** arcv) { printf("Initializing server...\n"); init_server(); printf("Waiting for new channels...\n"); listen_channels(); return 0; }
//Main procedure int main() { int size, i; printf("Original PID = %d\n", getpid()); init_server(); size = sizeof(self); //Begin listenning for(i=0; i<2; i++) { /* Accept connection request(s) */ size = sizeof(client[i]); printf("[Waiting for client request...]\n"); fflush(stdout); recvfrom(udp_sock, (MsgHeader*)&request_msg, sizeof(request_msg), 0, (struct sockaddr*)&client[i], &size); //Validate request if(request_msg.type != CON_REQUEST) { fprintf(stderr, "[ERROR: Illegal connection request from host %d]\n", client[i].sin_port); ack_msg.type = CON_REJECT; sendto(udp_sock, (MsgHeader*)&ack_msg.type, sizeof(ack_msg), 0, (struct sockaddr*)&client[i], size); exit(1); } printf("[Request valid from client %d]\n", htons(client[i].sin_port)); /* Create sub-process */ int cpid; if((cpid=fork()) == -1) { fprintf(stderr, "[ERROR: Sub-station creation failed]\n"); exit(EXIT_FAILURE); } if(cpid == 0) { //Call sub-process's function exit(sub_station()); }//end if (child process) else sleep(1); /* Send back the port address info of the sub-process on duty */ ack_msg.type = CON_ACK; ack_msg.dest.sin_family = AF_INET; ack_msg.dest.sin_port = htons(cpid); ack_msg.dest.sin_addr.s_addr = inet_addr(LOOPBACK_ADDR); sendto(udp_sock, (MsgHeader*)&ack_msg, sizeof(MsgHeader), 0, (struct sockaddr*)&client[i], size); }//end for-loop close(udp_sock); printf("[Main server going to sleep now]\n\n"); while(wait(NULL) != -1){ fprintf(stderr, "[ERROR: wait() passed]\n"); } return 0; }