int main(int argc , char *argv[]) { Client* client = mymalloc(sizeof(Client)); init_client(client); client->fdmax=STDIN_FILENO; FD_SET(STDIN_FILENO, &(client->fd_read_set)); while(TRUE) { client->fd_read_set_select = client->fd_read_set; client->fd_write_set_select = client->fd_write_set; select(client->fdmax+1, &(client->fd_read_set_select), &(client->fd_write_set_select), NULL, NULL); if (FD_ISSET(STDIN_FILENO, &(client->fd_read_set_select))) handle_std_input(client); else if(FD_ISSET(client->listening_fd, &(client->fd_read_set_select))) handle_new_client(client); else if(FD_ISSET(client->maintainer_fd, &(client->fd_read_set_select))) read_server_msg(client); else if(FD_ISSET(client->maintainer_fd, &(client->fd_write_set_select))) write_server_msg(client); else for(int i=1; i<=client->fdmax; ++i) if(FD_ISSET(i, &(client->fd_read_set_select))) read_client_msg(client, i); else if(FD_ISSET(i, &(client->fd_write_set_select))) write_client_msg(client, i); } myfree(client); return 0; }
int main(int argc, char **argv) { fd_set read_fdset, write_fdset; int i, opt; int max; sigset_t chld_set; while ((opt=getopt(argc, argv, "q")) != -1) { switch (opt) { case 'q': opt_quiet = 1; break; default: /* '?' */ fprintf(stderr, "usage: %s [-q] domainid domain-name [default user]\n", argv[0]); exit(1); } } if (argc - optind < 2 || argc - optind > 3) { fprintf(stderr, "usage: %s [-q] domainid domain-name [default user]\n", argv[0]); exit(1); } remote_domain_id = atoi(argv[optind]); remote_domain_name = argv[optind+1]; if (argc - optind >= 3) default_user = argv[optind+2]; init(remote_domain_id); sigemptyset(&chld_set); sigaddset(&chld_set, SIGCHLD); signal(SIGCHLD, sigchld_handler); /* * The main event loop. Waits for one of the following events: * - message from client * - message from agent * - new client * - child exited */ for (;;) { max = fill_fdsets_for_select(&read_fdset, &write_fdset); if (libvchan_buffer_space(vchan) <= (int)sizeof(struct msg_header)) FD_ZERO(&read_fdset); // vchan full - don't read from clients sigprocmask(SIG_BLOCK, &chld_set, NULL); if (child_exited) reap_children(); wait_for_vchan_or_argfd(vchan, max, &read_fdset, &write_fdset); sigprocmask(SIG_UNBLOCK, &chld_set, NULL); if (FD_ISSET(qrexec_daemon_unix_socket_fd, &read_fdset)) handle_new_client(); while (libvchan_data_ready(vchan)) handle_message_from_agent(); for (i = 0; i <= max_client_fd; i++) if (clients[i].state != CLIENT_INVALID && FD_ISSET(i, &read_fdset)) handle_message_from_client(i); } }
/** * Reads the thread specific userdata to figure out what * we need to handle. Things that purely effect the network * stack should be handled here, but otherwise we should defer * to the connection handlers. */ static void invoke_event_handler(worker_ev_userdata* data) { // Get the offending handle ev_io *watcher = data->watcher; int fd = watcher->fd; // Check if this is either of the listeners if (watcher == &data->netconf->tcp_client) { // Accept the new client handle_new_client(fd, data); // Reschedule the listener schedule_async(data->netconf, SCHEDULE_WATCHER, watcher); return; // If it is write ready, dispatch the write handler } else if (data->ready_events & EV_WRITE) { handle_client_writebuf(watcher, data); return; } // Check for UDP inbound if (watcher == &data->netconf->udp_client) { // Read the message and process if (!handle_udp_message(watcher, data)) { statsite_proxy_conn_handler handle = {data->netconf->config, data->netconf->proxy, watcher->data}; handle_client_connect(&handle); } // Reschedule the listener schedule_async(data->netconf, SCHEDULE_WATCHER, watcher); return; } /* * If it is not a listener, it must be a connected * client. We should just read all the available data, * append it to the buffers, and then invoke the * connection handlers. */ conn_info *conn = watcher->data; incref_client_connection(conn); if (!handle_client_data(watcher, data)) { statsite_proxy_conn_handler handle = {data->netconf->config, data->netconf->proxy, watcher->data}; handle_client_connect(&handle); } // Reschedule the watcher, unless told otherwise. if (conn->should_schedule) { schedule_async(data->netconf, SCHEDULE_WATCHER, watcher); } decref_client_connection(conn); }
int main(int argc, char *argv[]) { if (argc!=2) { fprintf(stderr,"usage: multi_ftp_server <server_local_path>\n"); exit(-1); } signal(SIGINT, sig_handler); getcwd(old_cwd,sizeof(old_cwd)); if (chdir(argv[1])==-1) { log_err("Bad Directory:"); exit(-1); } fd_set read_fds,write_fds; // temp file descriptor list for select() int listener; // listening socket descriptor FD_ZERO(&master); // clear the master and temp sets FD_ZERO(&w_master); FD_ZERO(&read_fds); FD_ZERO(&write_fds); init_protocol(); // get us a socket and bind it listener = do_bind(PORT); FD_SET(listener, &master); fdmax = listener + 1; for(;;) { read_fds = master; // copy it write_fds = w_master; if (select(fdmax+1, &read_fds, &write_fds, NULL, NULL) == -1) { perror("select"); exit(4); } // run through the existing connections looking for data to read int fdmax_nochange = fdmax; for(int i = 0; i <= fdmax_nochange; i++) { //debug("fdmax is %d",fdmax_nochange); if (FD_ISSET(i, &read_fds)) { if (i == listener) { fdmax = handle_new_client(listener) ; } else { fdmax = handle_recv_from_client(i); // handle data from a client } } if (FD_ISSET(i,&write_fds)) { fdmax = handle_send_to_client(i); } }//end run thrugh read fd_set } }
int main(int argc, char **argv) { fd_set read_fdset, write_fdset; int i; int max; sigset_t chld_set; if (argc != 2) { fprintf(stderr, "usage: %s domainid\n", argv[0]); exit(1); } init(atoi(argv[1])); sigemptyset(&chld_set); sigaddset(&chld_set, SIGCHLD); /* The main event loop. Waits for one of the following events: - message from client - message from agent - new client - child exited */ for (;;) { max = fill_fdsets_for_select(&read_fdset, &write_fdset); if (buffer_space_vchan_ext() <= sizeof(struct server_header)) FD_ZERO(&read_fdset); // vchan full - don't read from clients sigprocmask(SIG_BLOCK, &chld_set, NULL); if (child_exited) reap_children(); wait_for_vchan_or_argfd(max, &read_fdset, &write_fdset); sigprocmask(SIG_UNBLOCK, &chld_set, NULL); if (FD_ISSET(qrexec_daemon_unix_socket_fd, &read_fdset)) handle_new_client(); while (read_ready_vchan_ext()) handle_message_from_agent(); for (i = 0; i <= max_client_fd; i++) if (clients[i].state != CLIENT_INVALID && FD_ISSET(i, &read_fdset)) handle_message_from_client(i); for (i = 0; i <= max_client_fd; i++) if (clients[i].state != CLIENT_INVALID && FD_ISSET(i, &write_fdset)) write_buffered_data_to_client(i); } }
int main(int argc, char* argv[]){ //printf("argc:%d arg1:%s\n", argc, argv[1]); clr_connections(srv_state); clr_connections(dirty_state); int cont =1; next_fid =0; struct sigaction act; act.sa_handler = (update_clients_handler); if(sigaction(SIGALRM, &act, NULL)){ printf("error setting alarm handler\n"); } struct timeval tv; //kill(getpid(), SIGVTALRM); tv.tv_sec=0; tv.tv_usec = TIC_RATE; const struct itimerval it_update = {tv, tv}; if(setitimer(ITIMER_REAL, &it_update, NULL)) perror("setitimer failure"); openfd = socket(AF_INET, SOCK_DGRAM, 0); struct sockaddr_in server_addr; server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htonl(INADDR_ANY); server_addr.sin_port = htons(HOST_PORT); bind(openfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr_in)); while(cont){ struct client_data new_client; int socklen = sizeof(struct sockaddr_in); if(recvfrom(openfd, &new_client, sizeof(struct client_data), 0, (struct sockaddr*)&new_client.destaddr, &socklen)!=0){ printf("recieved msg. client_id=%d, address=%s\n", new_client.client_id, inet_ntoa(new_client.destaddr.sin_addr)); if(new_client.client_id>-1){ if(handle_msg(&new_client, dirty_state, openfd)){ printf("error handle_msg()\n"); return -1; } } else{ if(handle_new_client(&new_client, dirty_state, openfd)){ printf("error handle_msg()\n"); return -1; } } } } return 0; }
int main(int argc , char *argv[]) { Maintainer maintainer; init_maintainer(&maintainer); logger("<Server><main>maintainer initialized\n"); int opt = TRUE; if((maintainer.master_socket=socket(AF_INET, SOCK_STREAM, 0))==0){ logger("<Server><main>failed at master socket creation\n"); return 1; } fcntl(maintainer.master_socket, F_SETFL, O_NONBLOCK); if(setsockopt(maintainer.master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0){ logger("<Server><main>failed at master socket reuse\n"); return 1; } if(bind(maintainer.master_socket, (struct sockaddr *)&(maintainer.address), sizeof(maintainer.address)) < 0){ logger("<Server><main>failed at master socket binding\n"); return 1; } if (listen(maintainer.master_socket, 10) < 0){ logger("<Server><main>failed at master socket listen"); return 1; } FD_SET(maintainer.master_socket, &(maintainer.fd_read_set)); maintainer.max_sd = maintainer.master_socket; while(TRUE){ maintainer.fd_read_set_select = maintainer.fd_read_set; if ((select(maintainer.max_sd+1, &(maintainer.fd_read_set_select),NULL,NULL, NULL) < 0)) logger("<Server><main>error at select\n"); if (FD_ISSET(maintainer.master_socket, &(maintainer.fd_read_set_select))) handle_new_client(&maintainer); for(int i=0; i<MAX_CLIENTS; ++i){ int current_socket = maintainer.clients[i].socket_fd; if(current_socket == -1) continue; if(FD_ISSET(current_socket, &(maintainer.fd_read_set_select))) read_from_client(&maintainer, current_socket,&(maintainer.clients[i])); } } return 0; }
int main(int argc, char *argv[]) { char errbuf[ERRBUFLEN + 1]; apr_pool_t *pool; apr_proc_t proc; dynalogin_session_t *h; apr_status_t res; apr_sockaddr_t *sa; apr_socket_t *socket, *socket_new; char *cfg_filename; char *bind_address; int bind_port; int qlen = 32; int cfg_detach = 1; int ret; int done = 0; apr_hash_t *config; if(apr_initialize() != APR_SUCCESS) { fprintf(stderr, "apr_initialize failed\n"); return 1; } /* Just return an error if a client closes a socket */ apr_signal_block(SIGPIPE); openlog(argv[0], LOG_PID, LOG_AUTHPRIV); if((res = apr_pool_create(&pool, NULL)) != APR_SUCCESS) { syslog(LOG_ERR, "failed to create root pool: %s", apr_strerror(res, errbuf, ERRBUFLEN)); return 1; } if(argc == 2) cfg_filename = argv[1]; else cfg_filename = apr_psprintf(pool, "%s%c%s", SYSCONFDIR, DIR_SEP, DEFAULT_CONFIG_FILENAME); if(cfg_filename == NULL) { syslog(LOG_ERR, "apr_psprintf failed to create filename: %s", apr_strerror(res, errbuf, ERRBUFLEN)); return 1; } /* Read config */ if(dynalogin_read_config_from_file(&config, cfg_filename, pool) != DYNALOGIN_SUCCESS) { syslog(LOG_ERR, "failed to read config file %s", cfg_filename); return 1; } /* Set up DYNALOGIN session (threadsafe?) */ if(dynalogin_init(&h, pool, config) != DYNALOGIN_SUCCESS) { syslog(LOG_ERR, "failed to init dynalogin stack"); return 1; } /* Daemonize? */ GET_INT_PARAM(cfg_detach, config, DYNALOGIND_PARAM_DETACH) if((res=apr_proc_detach(cfg_detach)) != APR_SUCCESS) { syslog(LOG_ERR, "failed to detach: %s", apr_strerror(res, errbuf, ERRBUFLEN)); return 1; } /* Create socket for clients */ if((res=apr_socket_create(&socket, APR_INET, SOCK_STREAM, APR_PROTO_TCP, pool))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to create listening socket: %s", apr_strerror(res, errbuf, ERRBUFLEN)); return 1; } GET_STRING_PARAM_DEF(bind_address, config, DYNALOGIND_PARAM_BIND_ADDR, DEFAULT_BIND_ADDR) GET_INT_PARAM_DEF(bind_port, config, DYNALOGIND_PARAM_BIND_PORT, DEFAULT_BIND_PORT) if((res=apr_sockaddr_info_get(&sa, bind_address, APR_UNSPEC, bind_port, APR_IPV4_ADDR_OK || APR_IPV6_ADDR_OK, pool))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to resolve bind address: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } if((res=apr_socket_opt_set(socket, APR_SO_REUSEADDR, 1))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to set APR_SO_REUSEADDR: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } if((res=apr_socket_bind(socket, sa))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to bind: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } GET_STRING_PARAM_DEF(tls_cert, config, DYNALOGIND_PARAM_TLS_CERT, NULL) GET_STRING_PARAM_DEF(tls_key, config, DYNALOGIND_PARAM_TLS_KEY, NULL) if(tls_cert != NULL) { if(tls_key == NULL) { syslog(LOG_ERR, "%s specified, but %s not specified", DYNALOGIND_PARAM_TLS_CERT, DYNALOGIND_PARAM_TLS_KEY); return 1; } gnutls_global_init (); gnutls_certificate_allocate_credentials (&x509_cred); ret = gnutls_certificate_set_x509_key_file (x509_cred, tls_cert, tls_key, GNUTLS_X509_FMT_PEM); if (ret < 0) { syslog(LOG_ERR, "No certificate or key were found"); return 1; } generate_dh_params (); gnutls_priority_init (&priority_cache, "PERFORMANCE:%SERVER_PRECEDENCE", NULL); gnutls_certificate_set_dh_params (x509_cred, dh_params); } else if(tls_key == NULL) { syslog(LOG_ERR, "%s specified, but %s not specified", DYNALOGIND_PARAM_TLS_KEY, DYNALOGIND_PARAM_TLS_CERT); return 1; } /* Main loop */ while(done != 1) { if((res=apr_socket_listen(socket, qlen))!=APR_SUCCESS) { syslog(LOG_ERR, "failed apr_socket_listen: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } if((res=apr_socket_accept(&socket_new, socket, pool))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to accept incoming connection: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } syslog(LOG_INFO, "new incoming connection"); if((res=handle_new_client(socket_new, pool, h))!=APR_SUCCESS) { syslog(LOG_ERR, "failed to handle incoming connection: %s", apr_strerror(res, errbuf, ERRBUFLEN)); apr_socket_close(socket); return 1; } } apr_socket_close(socket); return 0; }
int main(int argc , char *argv[]) { Maintainer* maintainer = mymalloc(sizeof(Maintainer)); init_maintainer(maintainer); logger("<Server><main>maintainer initialized\n"); int opt = TRUE; if((maintainer->master_socket=socket(AF_INET, SOCK_STREAM, 0))==0) { logger("<Server><main>failed at master socket creation\n"); myfree(maintainer); exit(EXIT_FAILURE); } fcntl(maintainer->master_socket, F_SETFL, O_NONBLOCK); if(setsockopt(maintainer->master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0) { logger("<Server><main>failed at master socket reuse\n"); myfree(maintainer); exit(EXIT_FAILURE); } if(bind(maintainer->master_socket, (struct sockaddr *)&(maintainer->address), sizeof(maintainer->address)) < 0) { logger("<Server><main>failed at master socket binding\n"); myfree(maintainer); exit(EXIT_FAILURE); } if (listen(maintainer->master_socket, 10) < 0) { logger("<Server><main>failed at master socket listen"); exit(EXIT_FAILURE); } FD_SET(maintainer->master_socket, &(maintainer->fd_read_set)); FD_SET(maintainer->master_socket, &(maintainer->fd_exception_set)); maintainer->max_sd = maintainer->master_socket; while(TRUE) { maintainer->fd_read_set_select = maintainer->fd_read_set; maintainer->fd_write_set_select = maintainer->fd_write_set; maintainer->fd_exception_set_select = maintainer->fd_exception_set; if ((select(maintainer->max_sd+1, &(maintainer->fd_read_set_select), &(maintainer->fd_write_set_select), &(maintainer->fd_exception_set_select), NULL) < 0)) logger("<Server><main>error at select\n"); if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_read_set_select))) handle_new_client(maintainer); if (FD_ISSET(maintainer->master_socket, &(maintainer->fd_exception_set_select))) handle_server_exception(maintainer); struct Nodes_ll* prev = maintainer->clients; struct Nodes_ll* iterator = maintainer->clients; while(iterator != NULL) { int current_socket = iterator->node->socket_fd; if(FD_ISSET(current_socket, &(maintainer->fd_exception_set_select))) close_client_connection(maintainer, current_socket, iterator->node, TRUE); else if(FD_ISSET(current_socket, &(maintainer->fd_read_set_select))) if(!read_from_client(maintainer, current_socket, iterator->node)) if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select))) write_to_client(maintainer, current_socket, iterator->node); else if(FD_ISSET(current_socket, &(maintainer->fd_write_set_select))) write_to_client(maintainer, current_socket, iterator->node); if(iterator != maintainer->clients) { if(iterator->node->socket_fd == -1) { prev->next = iterator->next; myfree(iterator->node); struct Nodes_ll* tmp = iterator; iterator = iterator->next; myfree(tmp); } else { prev = prev->next; iterator = iterator->next; } } else if(iterator->node->socket_fd == -1) { /*marked for deletation*/ maintainer->clients = iterator->next; myfree(iterator->node); struct Nodes_ll* tmp = iterator; iterator = iterator->next; myfree(tmp); } else iterator = iterator->next; } } myfree(maintainer); return 0; }