int main(int argc, char **argv) { int server_socket; int port; if (argc != 2) { print_usage(); return 0; } port = atoi(argv[1]); if (!port) { printf("Invalid port number %s\n", argv[1]); print_usage(); return 0; } if (setup_crypt() < 0) return 0; signal(SIGINT, sigint); server_socket = start_server_sock(port); if (server_socket < 0) { printf("Could not create and bind listener socket\n"); cleanup_crypt(); } else accept_connections(server_socket); return 0; }
void ConnectionServer::accept_connections() { acceptor.async_accept(socket, [this](const boost::system::error_code& err_code) { if(!err_code) { handler(new Connection(conn_id_gen++, std::move(socket))); } accept_connections(); }); }
/*! This function is to be run in a separate thread. There it attaches itself to the given context and waits for incoming MB calls. These are passed on to __verify_MB_call(). \param ctx the CMPIContext to attach to. \sa accept_connections() */ static void __start_proxy_daemon(CMPIContext * ctx) { if (ctx != NULL) { CBAttachThread(__init_broker, ctx); } accept_connections(CIMOM_LISTEN_PORT, __verify_MB_call, 0); CBDetachThread(__init_broker, ctx); }
int main(int argc, char **argv) { int listen_fd; read_conf(); if ((listen_fd = listen_socket()) < 0) return 1; setgid(use_gid); setuid(use_uid); return accept_connections(listen_fd); }
void connect(Uint16 port) { IPaddress ip; if(SDLNet_ResolveHost(&ip,NULL,port)==-1) { printf("SDLNet_ResolveHost: %s\n", SDLNet_GetError()); exit(1); } serversock = SDLNet_TCP_Open(&ip); if(!serversock) { printf("SDLNet_TCP_Open: %s\n", SDLNet_GetError()); exit(2); } socketset = SDLNet_AllocSocketSet(32); if (!socketset) { printf("SDLNet_AllocSocketSet: %s\n", SDLNet_GetError()); exit(1); //most of the time this is a major error, but do what you want. } SDLNet_TCP_AddSocket(socketset, serversock); while(true) { int num = 0; if ((num = SDLNet_CheckSockets(socketset, 10000)) == -1) { printf("SDLNet_CheckSockets: %s\n", SDLNet_GetError()); //most of the time this is a system error, where perror might help you. perror("SDLNet_CheckSockets"); } else { accept_connections(); for(int i = 0; i < int(clients.size()); ++i) { if (clients[i]) clients[i]->update(); } for(int i = 0; i < int(clients.size()); ++i) { if (clients[i] && clients[i]->is_invalid()) { std::cout << "# client " << clients[i]->id << " got disconnected" << std::endl; SDLNet_TCP_DelSocket(socketset, clients[i]->tcpsock); SDLNet_TCP_Close(clients[i]->tcpsock); delete clients[i]; clients[i] = 0; } } } } }
ConnectionServer::ConnectionServer(NewConnectionHandler handler, std::string address, unsigned short port) : socket(io_service), endpoint(asio::ip::address().from_string(address), port), acceptor(io_service, endpoint), conn_id_gen(0), handler(handler) { BOOST_LOG_TRIVIAL(info) << "cbattleship-server listening on " << address << ":" << port << " ..."; accept_connections(); boost::thread thread(boost::bind(&boost::asio::io_service::run, &io_service)); }
// Wenn ein Kindprozess beendet wird, der einen // wartenden Server Prozess bedient hat, dann // schmeiss den Socket wieder auf die select() // Liste void sig_child(int code) { inetd *inetd; int status = -1; pid_t pid = wait(&status); if( ((inetd = search_child(pid)) != NULL) && (!strcmp(inetd->type,"wait")) ) { FD_SET(inetd->socket, &readfds); accept_connections(); } }
void acceptor::handle_accept(const boost::system::error_code& error) { BLOG(trace) << VIEW_FUNCTION; if (!error) { session_->start(upstream_host_, upstream_port_); if (!accept_connections()) { BLOG(error) << "Failure during call to accept."; } } else { BLOG(error) << "Error: " << error.message(); } }
/******************************************************************************\ Poll connections and dispatch any messages that arrive. \******************************************************************************/ void N_poll_server(void) { int i; if (n_client_id != N_HOST_CLIENT_ID) return; accept_connections(); /* Send to and receive from clients */ for (i = 0; i < N_CLIENTS_MAX; i++) if (!N_send_buffer(i) || !N_receive(i)) N_drop_client(i); }
void handle_accept(const boost::system::error_code& error) { if (!error) { session_->start(remote_host_,remote_port_); if (!accept_connections()) { std::cerr << "Failed to accept." << std::endl; } } else { std::cerr << error.message() << std::endl; } }
void handle_accept(const boost::system::error_code& error) { if (!error) { session_->start(upstream_host_,upstream_port_); if (!accept_connections()) { std::cerr << "Failure during call to accept." << std::endl; } } else { std::cerr << "Error: " << error.message() << std::endl; } }
void* trsender_thread_routine(void *arg) { SSL_CTX* ctx=NULL; SSL* ssl; char buf[BUF_SIZE]; size_t read=0; /*The sender acts as a server, so we perform the standard procedure to accept and verify SSL connection*/ peer_socket = accept_connections(server_socket); if (peer_socket==ERROR) { syslog(LOG_NOTICE,"ERROR accepting connection\n"); finished_transfer=FINISHED_ERR_SSL; pthread_exit(NULL); } if (!(ctx=fijar_contexto_SSL(MYCERTS, CACERT, &SSLv23_method, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT))) { syslog(LOG_NOTICE,"ERROR al fijar contexto\n"); finished_transfer=FINISHED_ERR_SSL; pthread_exit(NULL); } if (!(ssl=aceptar_canal_seguro_SSL(ctx, peer_socket))) { close(peer_socket); SSL_CTX_free(ctx); finished_transfer=FINISHED_ERR_SSL; pthread_exit(NULL); } transfer_ssl=ssl; if (evaluar_post_conectar_SSL(ssl)!=OK) { syslog(LOG_NOTICE,"El certificado del peer no es valido\n"); finished_transfer=FINISHED_ERR_SSL; cerrar_canal_SSL(transfer_ssl); pthread_exit(NULL); } /*connection succesful, sending file*/ if (!(transfer_file=fopen((char*)arg, "r"))) { finished_transfer=FINISHED_ERR; pthread_exit(NULL); } while (!feof(transfer_file) && !finished_transfer) {/* get request */ read=fread(buf, sizeof(char), BUF_SIZE, transfer_file); enviar_datos_SSL(transfer_ssl, buf, read, BUF_SIZE); } fclose(transfer_file); finished_transfer=FINISHED_OK; pthread_exit(NULL); }
int main(int argc, char **argv) { int socket, client_socket; int port = IRC_DEFAULT_PORT; /*Parameters processing*/ if (argc != 1 && argc != 2) { printf("%s <port (optional)>\n", argv[0]); return (EXIT_FAILURE); } else if (argc == 2) { port = atoi(argv[1]); } /*Runs in background*/ if (daemonize(SERVER_LOG_IDENT) == ERROR) { irc_exit_message(); return (EXIT_FAILURE); } /*Initializes server*/ socket = init_server(port, SERVER_MAX_CONNECTIONS); if (socket <= 0) { irc_exit_message(); exit(EXIT_FAILURE); } /*Initializes IRC server data*/ irc_server_data_init(); /*Accepts connexions and takes charge of them*/ while (1) { client_socket = accept_connections(socket); nbjoin_threads(); if (launch_thread(client_socket, irc_thread_routine) != OK) { syslog(LOG_ERR, "Server: Failed while launching a thread: %s", strerror(errno)); } } return (EXIT_SUCCESS); }
int _cdecl main(int argc, char *argv[]) { #ifdef WIN32 WSADATA wsa_data ; /* Initialize the winsock lib do we still want version 2.2? */ if ( WSAStartup(MAKEWORD(2,2), &wsa_data) == SOCKET_ERROR ){ printf("WSAStartup() failed : %lu\n", GetLastError()) ; return -1 ; } #endif /* WIN32 */ /* Save away the program name */ program = (char *)malloc(strlen(argv[0]) + 1); if (program == NULL) { printf("malloc for program name failed!\n"); return -1 ; } strcpy(program, argv[0]); init_netserver_globals(); netlib_init(); strncpy(local_host_name,"",sizeof(local_host_name)); local_address_family = AF_UNSPEC; strncpy(listen_port,TEST_PORT,sizeof(listen_port)); scan_netserver_args(argc, argv); check_if_inetd(); if (child) { /* we are the child of either an inetd or parent netserver via spawning (Windows) rather than fork()ing. if we were fork()ed we would not be coming through this way. set_server_sock() must be called before open_debug_file() or there is a chance that we'll toast the descriptor when we do not wish it. */ set_server_sock(); open_debug_file(); process_requests(); } else if (daemon_parent) { /* we are the parent daemonized netserver process. accept_connections() will decide if we want to spawn a child process */ accept_connections(); } else { /* we are the top netserver process, so we have to create the listen endpoint(s) and decide if we want to daemonize */ setup_listens(local_host_name,listen_port,local_address_family); if (want_daemonize) { daemonize(); } accept_connections(); } unlink_empty_debug_file(); #ifdef WIN32 WSACleanup(); #endif return 0; }
void daemonize() { #if defined(HAVE_FORK) if (debug) { fprintf(where, "%s: enter\n", __FUNCTION__); fflush(where); } /* flush the usual suspects */ fflush(stdin); fflush(stdout); fflush(stderr); switch (fork()) { case -1: fprintf(stderr, "%s: fork() error %s (errno %d)\n", __FUNCTION__, strerror(errno), errno); fflush(stderr); exit(1); case 0: /* perhaps belt and suspenders, but if we dump core, perhaps better to do so here. we won't worry about the call being successful though. raj 2011-07-08 */ chdir(DEBUG_LOG_FILE_DIR); /* we are the child. we should get a new "where" to match our new pid */ open_debug_file(); #ifdef HAVE_SETSID setsid(); #else setpgrp(); #endif /* HAVE_SETSID */ signal(SIGCLD, SIG_IGN); /* ok, we can start accepting control connections now */ accept_connections(); default: /* we are the parent, nothing to do but exit? */ exit(0); } #else fprintf(where, "%s called on platform which cannot daemonize\n", __FUNCTION__); fflush(where); exit(1); #endif /* HAVE_FORK */ }
int main(void) { FILE *fh; char line[1024]; struct sockaddr_in server; struct protoent *proto; struct servent *service; inetd *last = NULL; register inetd *inetd; // Biste root? if(getuid() != 0) { printf("You must be root!\n"); exit(1); } // Initialisiere readfds Array fuer select() FD_ZERO(&readfds); // Oeffne die Config Datei zum lesen if( (fh = fopen(CONF,"r")) == NULL) { perror("open"); exit(1); } // Verarbeite die Eingabe zeilenweise while(fgets(line,1024,fh) != NULL) { // Leerzeichen am Anfang der Zeile auslassen while(*zeiger == ' '){ zeiger++; } // Auskommentierte Zeilen auslassen if(*line != '#') { // Reserviere Speicher fuer eine neue inetd Struktur inetd = get_new_inetd(); // Ist das die erste inetd Struktur? // Dann merke sie Dir als den Anfang if(last == NULL) { anfang = inetd; } // Ansonsten zeigt der letzte Pointer auf den aktuellen else { last->next = inetd; } last = inetd; // Zerlege jede Zeile in ihre Bestandteile sscanf(line,"%10s %10s %10s %8s %20s %256s %256s %256s", inetd->name, inetd->type, inetd->prot, inetd->wait, inetd->user, inetd->path, inetd->prog, inetd->args); // Finde das Transport Protokoll heraus if( (proto = getprotobyname(inetd->prot)) == NULL) { snprintf(msg,256,"Unkown protocol %s!\n",inetd->prot); log(msg); exit(1); } // Finde das Application Layer Protokoll heraus if( (service = getservbyname(inetd->name,proto->p_name)) == NULL) { snprintf(msg,256,"Unkown protocol %s!\n",inetd->name); log(msg); exit(1); } // Adresse des Sockets server.sin_family = AF_INET; server.sin_port = service->s_port; server.sin_addr.s_addr = INADDR_ANY; // Oeffne einen Socket // TCP if(!strcmp(inetd->type,"stream")) { if( (inetd->socket = socket(AF_INET,SOCK_STREAM,proto->p_proto)) < 0) { perror("socket"); exit(1); } } // UDP else { if( (inetd->socket = socket(AF_INET,SOCK_DGRAM,proto->p_proto)) < 0) { perror("socket"); exit(1); } } // Binde den Socket an die Adresse if( (bind(inetd->socket, (struct sockaddr *)&server, sizeof(server))) < 0) { perror("bind"); exit(1); } // Setze die Listen Queue bei TCP Sockets if(!strcmp(inetd->type,"stream")) { listen(inetd->socket,QUEUE); } // Setze den Socket auf die select() Liste FD_SET(inetd->socket,&readfds); nfds = inetd->socket; } } fclose(fh); // Warte auf Verbindungsanfragen accept_connections(); return 0; }
static void *CR_Loop(void *arg) { #ifdef CR_FTB if (cr_ftb_init(nprocs)) exit(EXIT_FAILURE); #else char cr_msg_buf[MAX_CR_MSG_LEN]; char valstr[CRU_MAX_VAL_LEN]; fd_set set; int i, n, nfd = 0, ret; if (USE_LINEAR_SSH) { if (!show_on) { // This call is blocking (in case of error) // It must be kept in the CR thread int rv = accept_connections(); if ( rv != 0 ) { m_state_fail(); pthread_exit(NULL); } } } #endif CR_state_transition( CR_READY ); #ifdef CR_FTB // The main thread of mpirun_rsh is waiting for the CR thread to connect to FTB // before starting the mpispawn processes // Make the transition to the M_LAUNCH state // Use to signal the main thread of mpirun_rsh // This should be removed once we remove the use of FTB for this if (M_LAUNCH != m_state_transition(M_INITIALIZE|M_RESTART, M_LAUNCH)) { PRINT_ERROR("Internal error: transition failed\n"); m_state_fail(); pthread_exit(NULL); } #endif if ( checkpoint_interval > 0 ) { PRINT_DEBUG( DEBUG_FT_verbose, "Checkpoint interval = %d s\n", checkpoint_interval ); } while (1) { // Check if CR_thread_stop() has been called CR_state_lock(); if (cr_state == CR_STOPPED) { CR_state_unlock(); PRINT_DEBUG( DEBUG_FT_verbose, "Exit CR thread\n" ); pthread_exit(NULL); } CR_state_unlock(); #ifdef CR_FTB sleep(1); if (cr_ftb_app_ckpt_req || cr_ftb_finalize_ckpt) #else nfd = 0; FD_ZERO(&set); for (i = 0; i < nspawns; i++) { FD_SET(mpirun_fd[i], &set); nfd = (nfd >= mpirun_fd[i]) ? nfd : mpirun_fd[i]; } nfd += 1; struct timeval tv; do { tv.tv_sec = 1; tv.tv_usec = 0; ret = select(nfd, &set, NULL, NULL, &tv); } while ( ret==-1 && errno==EINTR ); if (ret < 0) { PRINT_ERROR_ERRNO("select(nfd=%d, set, NULL, NULL, tv={%lu,%lu}) failed", errno, nfd, tv.tv_sec, tv.tv_usec); return ((void *) -1); } else if (ret > 0) #endif { // Do not go further if not ready // This avoid bad interactions on file descriptors with the CR_Callback thread CR_state_lock(); if (cr_state != CR_READY) { CR_state_unlock(); continue; } CR_state_unlock(); #ifdef CR_FTB if (cr_ftb_app_ckpt_req) #else for (i = 0; i < nspawns; i++) { if (!FD_ISSET(mpirun_fd[i], &set)) continue; n = CR_MPDU_readline(mpirun_fd[i], cr_msg_buf, MAX_CR_MSG_LEN); if (n == 0) continue; if (CR_MPDU_parse_keyvals(cr_msg_buf) < 0) break; CR_MPDU_getval("cmd", valstr, CRU_MAX_VAL_LEN); if (strcmp(valstr, "app_ckpt_req") == 0) #endif { #ifdef CR_FTB cr_ftb_app_ckpt_req = 0; #endif unsigned int current_version = checkpoint_version; char buf[CR_MAX_FILENAME]; sprintf(buf, "%s.%d.sync", ckpt_filename, current_version); PRINT_DEBUG( DEBUG_FT_verbose, "Checkpoint request from the application\n" ); int rv = request_checkpoint( buf ); if ( rv < 0 ) { PRINT_ERROR( "Checkpoint failed\n" ); } else if ( rv > 0 ) { PRINT_DEBUG( DEBUG_FT_verbose, "Restarting from checkpoint\n" ); // Terminate the thread pthread_exit(NULL); } } #ifdef CR_FTB else if (cr_ftb_finalize_ckpt) #else else if (strcmp(valstr, "finalize_ckpt") == 0) #endif { // One process called MPI_finalize() #ifdef CR_FTB cr_ftb_finalize_ckpt = 0; #endif // Terminate the CR_thread CR_state_transition( CR_STOPPED ); pthread_exit(NULL); } #ifndef CR_FTB } #endif } else {
int select_on_sockets(){ //set of socket descriptors fd_set readfds; int max_clients = 30, activity, addrlen, i, valread; SOCKET client_socket[30], socket, new_socket; struct sockaddr_in address; for (i = 0; i < max_clients; i++) { client_socket[i] = 0; } while (TRUE) { FD_ZERO(&readfds); FD_SET(listen_socket, &readfds); //add child sockets for (i = 0; i < max_clients; i++) { socket = client_socket[i]; if (socket > 0) { FD_SET(socket, &readfds); } } //Accept and incoming connection puts("Waiting for incoming connections...\n"); //wait for an activity on any of the sockets activity = select(0, &readfds, NULL, NULL, NULL); if (activity == SOCKET_ERROR) { printf("select call failed with error code : %d", WSAGetLastError()); exit(EXIT_FAILURE); } //If something happened if (FD_ISSET(listen_socket, &readfds)) { if (accept_connections(&new_socket) != 0) { perror("accept"); exit(EXIT_FAILURE); } printf("New connection , socket fd is %d , ip is : %s , port : %d \n", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port)); //add new socket to array of sockets for (i = 0; i < max_clients; i++) { if (client_socket[i] == 0) { client_socket[i] = new_socket; printf("Adding to list of sockets at index %d \n", i); break; } } } //else its some IO operation on some other socket :) for (i = 0; i < max_clients; i++) { socket = client_socket[i]; //if client presend in read sockets if (FD_ISSET(socket, &readfds)) { //get details of the client getpeername(socket, (struct sockaddr*)&address, (int*)&addrlen); //Check if it was for closing , and also read the incoming message valread = receive(socket); if (valread <= 0){ closesocket(socket); client_socket[i] = 0; } } } } }