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;
}
