ServerSSL(boost::asio::io_service& io_service, int port) : m_io_service(io_service) , m_acceptor(io_service , boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4() , port)) , m_context(boost::asio::ssl::context::sslv23) , m_room(new SessionManager()) { std::cout << "Starting SSL Server" << std::endl; m_context.set_options( boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); m_context.set_password_callback(boost::bind(&ServerSSL::get_password, this)); m_context.use_certificate_chain_file("KEYS/ca.pem"); //m_context.use_certificate_chain_file_path ... m_context.use_private_key_file("KEYS/server.key", boost::asio::ssl::context::pem); m_context.use_tmp_dh_file("KEYS/dh2048.pem"); // Setup the communicator to allow rest of program to talk with // And send messages to other nodes. TheCommunicator::instance()->setupServer(m_room); std::cout << "SSL Server Ready." << std::endl; wait_for_connection(); }
PhronesisAgent::PhronesisAgent(boost::asio::io_service& io_service, const tcp::endpoint& endpoint) : m_io_service(io_service), m_acceptor(io_service, endpoint) { std::cout << "Creation d'un serveur " << std::endl; wait_for_connection(); }
int mdg_demo_start(void) { int s; if ((s = mdg_init(0)) != 0) { fprintf(stderr, "mdg_init failed with %d\n", s); return -1; } mdg_chat_init(); while (1) { if (io_port == -1) { if (read_from_sock(STDIN_FILENO) == 1) { exit(0); } } else { fprintf(stderr, "Listening for connection on port %d\n", io_port); if (wait_for_connection(io_port, &io_socket) == 0) { fprintf(stderr, "Reading input from socket...\n"); read_from_sock(io_socket); } fprintf(stderr, "Socket closed.\n"); close(io_socket); } } }
int main(int argc, char** argv) { // open system log and default to recording all logs (debug) openlog("calc-server", LOG_PERROR | LOG_PID | LOG_NDELAY, LOG_USER); setlogmask(LOG_UPTO(LOG_DEBUG)); int c; char* port = NULL; while (true) { static struct option long_options[] = { {"port", required_argument, 0, 'p'}, {0, 0, 0, 0} }; int option_index = 0; c = getopt_long(argc, argv, "p:", long_options, &option_index); if (c == -1) break; switch (c) { case 'p': port = optarg; if (port == NULL) { syslog(LOG_ERR, "Port argument missing!"); exit(EXIT_FAILURE); } break; case '?': break; } } // We want to listen on the specified port struct addrinfo* results = get_server_sockaddr(port); syslog(LOG_INFO, "Server listening on port %s", port); // Create a listening socket int sockfd = bind_socket(results); // Start listening on the socket if (listen(sockfd, BACKLOG) == -1) { perror("Unable to listen on socket"); syslog(LOG_ERR, "Unable to listen on socket"); exit(EXIT_FAILURE); } while (true) { // Wait for a connection and handle it int connectionfd = wait_for_connection(sockfd); handle_connection(connectionfd); } closelog(); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { errval_t err; debug_printf("Xeon Phi Test started on the card.\n"); err = xeon_phi_client_init(disp_xeon_phi_id()); EXPECT_SUCCESS(err, "xeon_phi_client_init"); xeon_phi_client_set_callbacks(&callbacks); alloc_local(); wait_for_connection(); char iface[30]; snprintf(iface, 30, "xphi_ump_bench.%u", XPHI_BENCH_CORE_HOST); debug_printf("sending open to host domain..\n"); err = xeon_phi_client_chan_open(disp_xeon_phi_id(), domainid, 0, local_frame, 2); EXPECT_SUCCESS(err, "xeon_phi_client_init"); #if XPHI_BENCH_INITIATOR_HOST debug_printf("giving time for host to initialize...\n"); for (uint32_t i = 0; i < 10; ++i) { delay_ms(4000); thread_yield(); } #endif #if XPHI_BENCH_INITIATOR_HOST debug_printf("---------------- normal run -----------------\n"); xphi_bench_start_echo(&xphi_uc); debug_printf("---------------- reversed run -----------------\n"); xphi_bench_start_echo(&xphi_uc_rev); #else #ifndef XPHI_BENCH_THROUGHPUT debug_printf("---------------- normal run -----------------\n"); xphi_bench_start_initator_rtt(&xphi_uc); debug_printf("---------------- reversed run -----------------\n"); xphi_bench_start_initator_rtt(&xphi_uc_rev); #else #ifdef XPHI_BENCH_SEND_SYNC debug_printf("---------------- normal run -----------------\n"); xphi_bench_start_initator_sync(&xphi_uc); debug_printf("---------------- reversed run -----------------\n"); xphi_bench_start_initator_sync(&xphi_uc_rev); #else debug_printf("---------------- normal run -----------------\n"); xphi_bench_start_initator_async(&xphi_uc); debug_printf("---------------- reversed run -----------------\n"); xphi_bench_start_initator_async(&xphi_uc_rev); #endif #endif #endif }
void listen_for_connection(int *listener) { int connection, connect_result; connect_result = -1; do { connect_result = wait_for_connection(*listener, &connection); } while(connect_result < 0); pthread_create(&listener_thread, NULL, (void *(*)(void *)) listen_for_connection, listener); handle_rpc(connection); }
int main(int argc, char** argv) { int c; static int server_port_flag = 0; char* server_port = NULL; static struct option long_options[] = { /*set flags */ {"port", required_argument, 0, 'p'}, {0, 0, 0, 0} }; while ((c = getopt_long(argc, argv, "p:",long_options,NULL)) != -1) { switch (c) { case 'p': server_port_flag = 1; server_port = optarg; break; case '?': exit(EXIT_FAILURE); break; } } openlog("server", LOG_PERROR | LOG_PID | LOG_NDELAY, LOG_USER); if (server_port_flag == 0) { syslog(LOG_WARNING, "No server port was specified"); exit(EXIT_FAILURE); } // We want to listen on port 5000 struct addrinfo* results = get_server_sockaddr(server_port); // Create a listening socket int sockfd = bind_socket(results); // Start listening on the socket if (listen(sockfd, BACKLOG) == -1) { perror("Unable to listen on socket"); exit(EXIT_FAILURE); } while (1) { // Wait for a connection and handle it int connectionfd = wait_for_connection(sockfd); handle_connection(connectionfd); } closelog(); /* close the syslog connection */ return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { int client, server; int master_sock; int localport; char* log_file_loc; if (argc == 4) { if (strcmp(argv[1], "-v") != 0) { show_usage(argv[0]); } verbose = true; localport = atoi(argv[2]); log_file_loc = argv[3]; } else if (argc == 3) { localport = atoi(argv[1]); log_file_loc = argv[2]; } else { show_usage(argv[0]); } if (strcmp(log_file_loc, "stdout") == 0) { logfile = stdout; verbose = false; } else { logfile = fopen(log_file_loc, "a"); } if (logfile == NULL) { fprintf(stderr, "log_file %s could not be opened\n", argv[2]); exit(2); } assert(localport > 0); signal(SIGINT, cleanup); signal(SIGCHLD, sigreap); master_sock = create_server_sock(localport); for (;;) { if ((client = wait_for_connection(master_sock)) < 0) { continue; } if ((server = create_proxy(client)) < 0) { continue; } if (!fork()) { syslog(LOG_INFO, "connecting to %s:%d fd=%d\n", remoteaddr, remoteport, server); service_client(client, server); } close(client); close(server); } }
void PhronesisAgent::handle_accept(const boost::system::error_code& error, connection_ptr new_connection) { if (!error) { std::string s = new_connection.get()->socket().remote_endpoint().address().to_string(); std::cout << "Accepted connection from " << s << std::endl; Treatment_ptr session = Treatment::create(new_connection); //Shall we call wait_for_connection even if there is an error? wait_for_connection(); } else { std::cerr << "Connection refusee" << std::endl; } }
void listen_for_connection(host_port *info) { pthread_t thread; int connection, connect_result, listener; connect_result = set_up_listener(info->port, &listener); connect_result = -1; while(1) { do { connect_result = wait_for_connection(listener, &connection); } while(connect_result < 0); connect_result = 0; safe_recv(connection, &connect_result, sizeof(int)); if(connect_result) { pthread_create(&thread, NULL, (void *(*)(void *))receive_int, (void *)&connection); } } }
/** * @brief On Connections, creates and spawns the SSL session. * @param new_connection * @param error */ void handle_accept(connection_ptr new_connection, const boost::system::error_code& error) { if(!error) { std::cout << "SSL Connection Accepted" << std::endl; session_ptr new_session = Session::create(m_io_service, new_connection, m_room); m_room->join(new_session); // keep it alive! // Loop back and handle next connection wait_for_connection(); } else { std::cout << "Error SSL Connection." << std::endl; } }
int main(int argc, char *argv[]) { int thread_counter = 0; int sockfd; int newsockfd; pthread_t workers[NUM_WORKERS]; my_router = malloc(sizeof(struct router)); // parse config if (!parse_config(argc, argv)) { return -1; } // set up this node sockfd = create_node(port); if (sockfd == -1) { return -1; } dbg("Erstellt"); // init list of all connected neighbours LIST_INIT(&neighbour_head); // init blacklist package_id_blacklist[0] = 1;// without this, packages with ID 0 are blacklisted from the beginning while (1) { newsockfd = wait_for_connection(sockfd);// wait for a new node to connect pthread_create(&workers[thread_counter], NULL, worker_init, (void *)newsockfd);// create a new thread for handling this connection thread_counter += 1; if (thread_counter >= NUM_WORKERS) { thread_counter = 0; } } // clean up mutexes and conditions pthread_mutex_destroy(&mutex_neighbours); pthread_cond_destroy(&cond_neighbours); pthread_mutex_destroy(&mutex_router); pthread_cond_destroy(&cond_router); pthread_mutex_destroy(&mutex_blacklist); pthread_cond_destroy(&cond_blacklist); return 0; }
int main(int ac, char **av) { int fd; int ret; if (ac > 3 || ac == 2) return (msg_error(EUSAGE, 0)); if (ac == 3) fd = connect_to_server(av[1], atoi(av[2])); else fd = wait_for_connection(); if (fd <= 0) return (EXIT_FAILURE); ret = launch_client(fd); if (close(fd) == -1) return (msg_error(ECLOSE, 1)); return (ret); }
int handle_connections(int portnum) { int listenfd; int acceptfd; pid_t childpid; listenfd = create_listener(portnum); if (listenfd < 0) { fprintf(stderr, "Warning: Exiting main network event loop\n"); return -1; } while (1) { fprintf(stderr, "Notice: Waiting for a connection...\n"); acceptfd = wait_for_connection(listenfd); if (acceptfd < 0) { fprintf(stderr, "Warning: Exiting main network event loop\n"); return -1; } childpid = fork(); if (childpid > 0) { close(acceptfd); fprintf(stderr, "Notice: Child process id=%d forked to handle incoming connection\n", childpid); } else if (childpid == 0) { close(listenfd); fprintf(stderr, "Notice: Processing request in child process\n"); read_incoming_data(acceptfd); exit(0); } else { perror("fork"); fprintf(stderr, "Error: Unable to create child process to handle new connection\n"); } } } /* handle_connections() */
void udp_server(const char* name, int port, int mtu) { int sock, ret; struct sockaddr_in cli_addr; socklen_t cli_addr_size; char buffer[MAX_BUFFER]; priv_data_st priv; gnutls_session_t session; gnutls_datum_t cookie_key; gnutls_dtls_prestate_st prestate; unsigned char sequence[8]; ret = gnutls_key_generate(&cookie_key, GNUTLS_COOKIE_KEY_SIZE); if (ret < 0) { fprintf(stderr, "Cannot generate key\n"); exit(1); } ret = listen_socket (name, port, SOCK_DGRAM); if (ret < 0) { fprintf(stderr, "Cannot listen\n"); exit (1); } for (;;) { printf("Waiting for connection...\n"); sock = wait_for_connection(); if (sock < 0) continue; cli_addr_size = sizeof(cli_addr); ret = recvfrom(sock, buffer, sizeof(buffer), MSG_PEEK, (struct sockaddr*)&cli_addr, &cli_addr_size); if (ret > 0) { memset(&prestate, 0, sizeof(prestate)); ret = gnutls_dtls_cookie_verify(&cookie_key, &cli_addr, sizeof(cli_addr), buffer, ret, &prestate); if (ret < 0) /* cookie not valid */ { priv_data_st s; memset(&s,0,sizeof(s)); s.fd = sock; s.cli_addr = (void*)&cli_addr; s.cli_addr_size = sizeof(cli_addr); printf("Sending hello verify request to %s\n", human_addr ((struct sockaddr *) &cli_addr, sizeof(cli_addr), buffer, sizeof(buffer))); gnutls_dtls_cookie_send(&cookie_key, &cli_addr, sizeof(cli_addr), &prestate, (gnutls_transport_ptr_t)&s, push_func); /* discard peeked data*/ recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&cli_addr, &cli_addr_size); continue; } printf ("Accepted connection from %s\n", human_addr ((struct sockaddr *) &cli_addr, sizeof(cli_addr), buffer, sizeof (buffer))); } else continue; session = initialize_session(1); gnutls_dtls_prestate_set(session, &prestate); if (mtu) gnutls_dtls_set_mtu(session, mtu); priv.session = session; priv.fd = sock; priv.cli_addr = (struct sockaddr *)&cli_addr; priv.cli_addr_size = sizeof(cli_addr); gnutls_transport_set_ptr (session, &priv); gnutls_transport_set_push_function (session, push_func); gnutls_transport_set_pull_function (session, pull_func); gnutls_transport_set_pull_timeout_function (session, pull_timeout_func); do { ret = gnutls_handshake(session); } while(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED); if (ret < 0) { fprintf(stderr, "Error in handshake(): %s\n", gnutls_strerror(ret)); gnutls_deinit(session); continue; } for(;;) { do { ret = gnutls_record_recv_seq(session, buffer, MAX_BUFFER, sequence); } while(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED); if (ret == GNUTLS_E_REHANDSHAKE) { fprintf (stderr, "*** Received hello message\n"); do { ret = gnutls_handshake (session); } while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN); if (ret == 0) continue; } if (ret < 0) { fprintf(stderr, "Error in recv(): %s\n", gnutls_strerror(ret)); break; } if (ret == 0) { printf("EOF\n\n"); break; } buffer[ret] = 0; printf("received[%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x]: %s\n", sequence[0], sequence[1], sequence[2], sequence[3], sequence[4], sequence[5], sequence[6], sequence[7], buffer); if (check_command(session, buffer) == 0) { /* reply back */ ret = gnutls_record_send(session, buffer, ret); if (ret < 0) { fprintf(stderr, "Error in send(): %s\n", gnutls_strerror(ret)); break; } } } } gnutls_deinit(session); }
int main(int argc, char *argv[], char *env[]) { struct sockaddr_storage from; int on = 1; socklen_t fromlen; register int ch; int i; #if defined(HAS_IPPROTO_IP) && defined(IP_TOS) int tos = -1; #endif initsetproctitle(argc, argv, env); pfrontp = pbackp = ptyobuf; netip = netibuf; #ifdef USE_SSL /* we need to know the fullpath to the location of the * certificate that we will be running with as we cannot * be sure of the cwd when we are launched */ sprintf(cert_filepath,"%s/%s",X509_get_default_cert_dir(), "telnetd.pem"); ssl_cert_file=cert_filepath; ssl_key_file=NULL; #endif /* USE_SSL */ while ((ch = getopt(argc, argv, "d:a:e:lhnNr:I:D:B:sS:a:X:L:z:")) != EOF) { switch(ch) { #ifdef USE_SSL case 'z': { char *origopt; origopt=strdup(optarg); optarg=strtok(origopt,","); while(optarg!=NULL) { if (strcmp(optarg, "debug") == 0 ) { ssl_debug_flag=1; } else if (strcmp(optarg, "ssl") == 0 ) { ssl_only_flag=1; } else if (strcmp(optarg, "certsok") == 0 ) { ssl_certsok_flag=1; } else if ( (strcmp(optarg, "!ssl") == 0) || (strcmp(optarg, "nossl") == 0) ) { /* we may want to switch SSL negotiation off * for testing or other reasons */ ssl_disabled_flag=1; } else if (strcmp(optarg, "certrequired") == 0 ) { ssl_cert_required=1; } else if (strcmp(optarg, "secure") == 0 ) { ssl_secure_flag=1; } else if (strncmp(optarg, "verify=", strlen("verify=")) == 0 ) { ssl_verify_flag=atoi(optarg+strlen("verify=")); } else if (strncmp(optarg, "cert=", strlen("cert=")) == 0 ) { ssl_cert_file=optarg+strlen("cert="); } else if (strncmp(optarg, "key=", strlen("key=")) == 0 ) { ssl_key_file=optarg+strlen("key="); } else if (strncmp(optarg,"cipher=", strlen("cipher="))==0) { ssl_cipher_list=optarg+strlen("cipher="); } else { /* report when we are given rubbish so that * if the user makes a mistake they have to * correct it! */ fprintf(stderr,"Unknown SSL option %s\n",optarg); fflush(stderr); exit(1); } /* get the next one ... */ optarg=strtok(NULL,","); } /* if (origopt!=NULL) free(origopt); */ } break; #endif /* USE_SSL */ #ifdef AUTHENTICATE case 'a': /* * Check for required authentication level */ if (strcmp(optarg, "debug") == 0) { extern int auth_debug_mode; auth_debug_mode = 1; } else if (strcasecmp(optarg, "none") == 0) { auth_level = 0; } else if (strcasecmp(optarg, "other") == 0) { auth_level = AUTH_OTHER; } else if (strcasecmp(optarg, "user") == 0) { auth_level = AUTH_USER; } else if (strcasecmp(optarg, "valid") == 0) { auth_level = AUTH_VALID; } else if (strcasecmp(optarg, "off") == 0) { /* * This hack turns off authentication */ auth_level = -1; } else { fprintf(stderr, "telnetd: unknown authorization level for -a\n"); } break; #endif /* AUTHENTICATE */ #ifdef BFTPDAEMON case 'B': bftpd++; break; #endif /* BFTPDAEMON */ case 'd': if (strcmp(optarg, "ebug") == 0) { debug++; break; } usage(); /* NOTREACHED */ break; #ifdef DIAGNOSTICS case 'D': /* * Check for desired diagnostics capabilities. */ if (!strcmp(optarg, "report")) { diagnostic |= TD_REPORT|TD_OPTIONS; } else if (!strcmp(optarg, "exercise")) { diagnostic |= TD_EXERCISE; } else if (!strcmp(optarg, "netdata")) { diagnostic |= TD_NETDATA; } else if (!strcmp(optarg, "ptydata")) { diagnostic |= TD_PTYDATA; } else if (!strcmp(optarg, "options")) { diagnostic |= TD_OPTIONS; } else { usage(); /* NOT REACHED */ } break; #endif /* DIAGNOSTICS */ #ifdef AUTHENTICATE case 'e': if (strcmp(optarg, "debug") == 0) { extern int auth_debug_mode; auth_debug_mode = 1; break; } usage(); /* NOTREACHED */ break; #endif /* AUTHENTICATE */ case 'h': hostinfo = 0; break; #ifdef LINEMODE case 'l': alwayslinemode = 1; break; #endif /* LINEMODE */ case 'L': loginprg = strdup(optarg); /* XXX what if strdup fails? */ break; case 'n': keepalive = 0; break; case 'N': numeric_hosts = 1; break; #ifdef SecurID case 's': /* SecurID required */ require_SecurID = 1; break; #endif /* SecurID */ case 'S': #ifdef HAS_GETTOS if ((tos = parsetos(optarg, "tcp")) < 0) fprintf(stderr, "%s%s%s\n", "telnetd: Bad TOS argument '", optarg, "'; will try to use default TOS"); #else fprintf(stderr, "%s%s\n", "TOS option unavailable; ", "-S flag not supported\n"); #endif break; #ifdef AUTHENTICATE case 'X': /* * Check for invalid authentication types */ auth_disable_name(optarg); break; #endif /* AUTHENTICATE */ default: fprintf(stderr, "telnetd: %c: unknown option\n", ch); /* FALLTHROUGH */ case '?': usage(); /* NOTREACHED */ } } #ifdef USE_SSL if (ssl_secure_flag || ssl_cert_required || ssl_certsok_flag) { /* in secure mode we *must* switch on the base level * verify checking otherwise we cannot abort connections * at the right place! */ if (ssl_verify_flag==0) ssl_verify_flag=1; } /* if we are not running in debug then any error * stuff from SSL debug *must* not go down * the socket (which 0,1,2 are all pointing to by * default) */ if (ssl_debug_flag) ssl_log_file="/telnetd.log"; if (!do_ssleay_init(1)) { if (bio_err!=NULL) { BIO_printf(bio_err,"do_ssleay_init() failed\n"); ERR_print_errors(bio_err); } else { fflush(stderr); fprintf(stderr,"do_ssleay_init() failed\n"); ERR_print_errors_fp(stderr); } exit(1); } if (ssl_debug_flag) { BIO_printf(bio_err,"secure %d certrequired %d verify %d\n", ssl_secure_flag,ssl_cert_required,ssl_verify_flag); for(i=0;i<argc;i++) BIO_printf(bio_err,"argv[%d]=\"%s\"\n",i,argv[i]); } #endif /* USE_SSL */ argc -= optind; argv += optind; if (debug) { if (argc > 1) { usage(); /* NOTREACHED */ } wait_for_connection((argc == 1) ? *argv : "telnet"); } openlog("telnetd", LOG_PID | LOG_ODELAY, LOG_DAEMON); fromlen = sizeof (from); if (getpeername(0, (struct sockaddr *)&from, &fromlen) < 0) { fatalperror(2, "getpeername"); } if (keepalive && setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on)) < 0) { syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m"); } #if defined(HAS_IPPROTO_IP) && defined(IP_TOS) { # if defined(HAS_GETTOS) struct tosent *tp; if (tos < 0 && (tp = gettosbyname("telnet", "tcp"))) tos = tp->t_tos; # endif if (tos < 0) tos = 020; /* Low Delay bit */ if (tos && (setsockopt(0, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) && (errno != ENOPROTOOPT) ) syslog(LOG_WARNING, "setsockopt (IP_TOS): %m"); } #endif /* defined(HAS_IPPROTO_IP) && defined(IP_TOS) */ #ifdef USE_SSL /* do the SSL stuff now ... before we play with pty's */ SSL_set_fd(ssl_con,0); if (ssl_only_flag) { /* hmm ... only when running talking to things like * https servers should we hit this code and then * we really don't care *who* we talk to :-) */ SSL_set_verify(ssl_con,ssl_verify_flag,NULL); if (SSL_accept(ssl_con) <= 0) { static char errbuf[1024]; sprintf(errbuf,"SSL_accept error %s\n", ERR_error_string(ERR_get_error(),NULL)); syslog(LOG_WARNING, "%s", errbuf); BIO_printf(bio_err,"%s",errbuf); /* go to sleep to make sure we are noticed */ sleep(10); SSL_free(ssl_con); _exit(1); } else { ssl_active_flag=1; } } #endif /* USE_SSL */ net = 0; netopen(); doit((struct sockaddr *)&from, fromlen); /* NOTREACHED */ return 0; } /* end of main */
int main(int argc, char *argv[]) { int source_port; char *destination_address; int destination_port; int server_sockfd = -1, client_sockfd = -1, target_sockfd = -1, admin_sockfd = -1, admin_client_sockfd = -1; char *lock_filename; /* Check parameters */ if(argc != 5) { print_usage(); _exit(1); } /* Get parameter values */ source_port = atoi(argv[1]); destination_address = strdup(argv[2]); destination_port = atoi(argv[3]); lock_filename = strdup(argv[4]); /* Create signal handlers */ signal(SIGINT, cleanup); /* Event handler for interruption */ signal(SIGCHLD, sigreap); /* Event handler when a child terminates */ /* Create server socket */ server_sockfd = create_server_socket(source_port); set_nonblock(server_sockfd); /* Create admin socket */ admin_sockfd = create_admin_socket("/tmp/disnix-tcp-proxy.sock"); set_nonblock(admin_sockfd); /* Main loop */ while(TRUE) { int status; /* Create admin client socket if there is an incoming connection */ if((admin_client_sockfd = wait_for_connection(admin_sockfd)) >= 0) { char msg[BUFFER_SIZE]; printf("Admin connection from client\n"); sprintf(msg, "%d", num_of_connections); if(send(admin_client_sockfd, msg, strlen(msg), 0) < 0) fprintf(stderr, "Error sending message to admin client: %s\n", strerror(errno)); close(admin_client_sockfd); admin_client_sockfd = -1; } /* If we want to block do not accept any incoming client connections */ if(is_blocking(lock_filename)) continue; /* Create client if there is an incoming connection */ if((client_sockfd = wait_for_connection(server_sockfd)) < 0) continue; /* Connect to the remote host */ if((target_sockfd = open_remote_host(destination_address, destination_port)) < 0) { close(client_sockfd); client_sockfd = -1; continue; } /* Fork a new process for each incoming client */ status = fork(); if(status == 0) { printf("Connection from client\n"); close(server_sockfd); close(admin_sockfd); do_proxy(client_sockfd, target_sockfd); abort(); } else if(status == -1) fprintf(stderr, "Error in forking process\n"); else num_of_connections++; /* Close the connections to the remote host and client */ close(client_sockfd); client_sockfd = -1; close(target_sockfd); target_sockfd = -1; } return 0; }
int main (void) { int listen_sd; int sock, ret; struct sockaddr_in sa_serv; struct sockaddr_in cli_addr; socklen_t cli_addr_size; gnutls_session_t session; char buffer[MAX_BUFFER]; priv_data_st priv; gnutls_datum_t cookie_key; gnutls_dtls_prestate_st prestate; int mtu = 1400; unsigned char sequence[8]; /* this must be called once in the program */ gnutls_global_init (); gnutls_certificate_allocate_credentials (&x509_cred); gnutls_certificate_set_x509_trust_file (x509_cred, CAFILE, GNUTLS_X509_FMT_PEM); gnutls_certificate_set_x509_crl_file (x509_cred, CRLFILE, GNUTLS_X509_FMT_PEM); ret = gnutls_certificate_set_x509_key_file (x509_cred, CERTFILE, KEYFILE, GNUTLS_X509_FMT_PEM); if (ret < 0) { printf("No certificate or key were found\n"); exit(1); } generate_dh_params (); gnutls_certificate_set_dh_params (x509_cred, dh_params); gnutls_priority_init (&priority_cache, "PERFORMANCE:-VERS-TLS-ALL:+VERS-DTLS1.0:%SERVER_PRECEDENCE", NULL); gnutls_key_generate (&cookie_key, GNUTLS_COOKIE_KEY_SIZE); /* Socket operations */ listen_sd = socket (AF_INET, SOCK_DGRAM, 0); memset (&sa_serv, '\0', sizeof (sa_serv)); sa_serv.sin_family = AF_INET; sa_serv.sin_addr.s_addr = INADDR_ANY; sa_serv.sin_port = htons (PORT); { /* DTLS requires the IP don't fragment (DF) bit to be set */ #if defined(IP_DONTFRAG) int optval = 1; setsockopt (listen_sd, IPPROTO_IP, IP_DONTFRAG, (const void *) &optval, sizeof (optval)); #elif defined(IP_MTU_DISCOVER) int optval = IP_PMTUDISC_DO; setsockopt(listen_sd, IPPROTO_IP, IP_MTU_DISCOVER, (const void*) &optval, sizeof (optval)); #endif } bind (listen_sd, (struct sockaddr *) &sa_serv, sizeof (sa_serv)); printf ("UDP server ready. Listening to port '%d'.\n\n", PORT); for (;;) { printf ("Waiting for connection...\n"); sock = wait_for_connection (listen_sd); if (sock < 0) continue; cli_addr_size = sizeof (cli_addr); ret = recvfrom (sock, buffer, sizeof (buffer), MSG_PEEK, (struct sockaddr *) &cli_addr, &cli_addr_size); if (ret > 0) { memset (&prestate, 0, sizeof (prestate)); ret = gnutls_dtls_cookie_verify (&cookie_key, &cli_addr, sizeof (cli_addr), buffer, ret, &prestate); if (ret < 0) /* cookie not valid */ { priv_data_st s; memset (&s, 0, sizeof (s)); s.fd = sock; s.cli_addr = (void *) &cli_addr; s.cli_addr_size = sizeof (cli_addr); printf ("Sending hello verify request to %s\n", human_addr ((struct sockaddr *) &cli_addr, sizeof (cli_addr), buffer, sizeof (buffer))); gnutls_dtls_cookie_send (&cookie_key, &cli_addr, sizeof (cli_addr), &prestate, (gnutls_transport_ptr_t) & s, push_func); /* discard peeked data */ recvfrom (sock, buffer, sizeof (buffer), 0, (struct sockaddr *) &cli_addr, &cli_addr_size); usleep (100); continue; } printf ("Accepted connection from %s\n", human_addr ((struct sockaddr *) &cli_addr, sizeof (cli_addr), buffer, sizeof (buffer))); } else continue; session = initialize_tls_session (); gnutls_dtls_prestate_set (session, &prestate); gnutls_dtls_set_mtu (session, mtu); priv.session = session; priv.fd = sock; priv.cli_addr = (struct sockaddr *) &cli_addr; priv.cli_addr_size = sizeof (cli_addr); gnutls_transport_set_ptr (session, &priv); gnutls_transport_set_push_function (session, push_func); gnutls_transport_set_pull_function (session, pull_func); gnutls_transport_set_pull_timeout_function (session, pull_timeout_func); do { ret = gnutls_handshake (session); } while (ret < 0 && gnutls_error_is_fatal (ret) == 0); if (ret < 0) { fprintf (stderr, "Error in handshake(): %s\n", gnutls_strerror (ret)); gnutls_deinit (session); continue; } printf ("- Handshake was completed\n"); for (;;) { do { ret = gnutls_record_recv_seq (session, buffer, MAX_BUFFER, sequence); } while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED); if (ret < 0) { fprintf (stderr, "Error in recv(): %s\n", gnutls_strerror (ret)); break; } if (ret == 0) { printf ("EOF\n\n"); break; } buffer[ret] = 0; printf ("received[%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x]: %s\n", sequence[0], sequence[1], sequence[2], sequence[3], sequence[4], sequence[5], sequence[6], sequence[7], buffer); /* reply back */ ret = gnutls_record_send (session, buffer, ret); if (ret < 0) { fprintf (stderr, "Error in send(): %s\n", gnutls_strerror (ret)); break; } } gnutls_bye (session, GNUTLS_SHUT_WR); gnutls_deinit (session); } close (listen_sd); gnutls_certificate_free_credentials (x509_cred); gnutls_priority_deinit (priority_cache); gnutls_global_deinit (); return 0; }
/* * Never returns. */ void main_loop(int sockfd) { while (1) { int clientfd = wait_for_connection(sockfd); INFO("main_loop(): New client. clientfd: %d\n", clientfd); if (clientfd == -1) { ERROR("main_loop(): error occurred in wait_for_connection"); continue; } int cont = 1; while (cont) { INFO("main_loop(): Waiting for message...\n"); controller_msg_hdr_t hdr; if (recv_msg_hdr(clientfd, &hdr) == -1) { ERROR("main_loop(): Error occurred in recv_msg_hdr()\n"); cont = 0; break; } INFO("main_loop(): Servicing message of type %s\n", msg_type_to_string(hdr.type)); switch (hdr.type) { case CTRL_MSG_JSON: { if (hdr.len > MAX_JSON_MSG_LEN) { WARN("main_loop(): JSON message may be excessively large.\n"); } char * json_msg = ALLOC(char, hdr.len); if (recv_msg_string(clientfd, json_msg, hdr.len) == -1) { ERROR("main_loop(): Error occurred in recv_msg_string()\n"); free(json_msg); cont = 0; break; } json_msg[hdr.len - 1] = '\0'; INFO("main_loop(): JSON Message received. Contents:\n%s\n", json_msg); char * return_msg = handle_msg(json_msg); INFO("main_loop(): Replying to client with message: \n%s\n", return_msg); if (send_msg_hdr(clientfd, CTRL_MSG_JSON, strlen(return_msg) + 1) != -1) { if (send_msg_string(clientfd, return_msg) != -1) { } else { ERROR("send_msg_string() failed, terminating communication with client...\n"); cont = 0; } } else { ERROR("send_msg_hdr() failed, terminating communication with client...\n"); cont = 0; } free(return_msg); free(json_msg); break; } case CTRL_MSG_REPLY: { WARN("main_loop(): Received CTRL_MSG_REPLY... ignoring message\n"); break; } case CTRL_MSG_EXIT: { INFO("main_loop(): Received CTRL_MSG_EXIT\n"); cont = 0; break; } case CTRL_MSG_ERROR: { ERROR("main_loop(): Received CTRL_MSG_ERROR\n"); cont = 0; break; } default: { ERROR("main_loop(): Message of unknown type was received. Terminating communication..\n"); cont = 0; break; } } } INFO("main_loop(): Breaking connection with client...\n"); close_socket(clientfd); } }
int main(int argc, char *argv[], char *dummy[]) { ushort tcp_port = 4711; struct srv_info sinfo; uint cmd; uint max_msglen; struct sockaddr_in srv_addr; int lstn_sd, peer_sd; int srv_id = 0, srv_cnt = 0;; own_node_addr = own_node(); memset(&sinfo, 0, sizeof(sinfo)); if (signal(SIGALRM, sig_alarm) == SIG_ERR) die("Server master: can't catch alarm signals\n"); printf("****** TIPC Benchmark Server Started ******\n"); /* Create socket for communication with master: */ reset: master_sd = socket(AF_TIPC, SOCK_RDM, 0); if (master_sd < 0) die("Server: Can't create socket to master\n"); if (bind(master_sd, (struct sockaddr *)&srv_ctrl_addr, sizeof(srv_ctrl_addr))) die("Server: Failed to bind to master socket\n"); /* Wait for command from master: */ srv_from_master(&cmd, &max_msglen, 0, 0); buf = malloc(max_msglen); if (!buf) die("Failed to create buffer of size %u\n", ntohl(max_msglen)); /* Create TIPC or TCP listening socket: */ if (cmd == TIPC_CONN) { lstn_sd = socket (AF_TIPC, SOCK_STREAM,0); if (lstn_sd < 0) die("Server master: can't create listening socket\n"); if (bind(lstn_sd, (struct sockaddr *)&srv_lstn_addr, sizeof(srv_lstn_addr)) < 0) die("TIPC Server master: failed to bind port name\n"); printf("****** TIPC Listener Socket Created ******\n"); srv_to_master(SRV_INFO, 0); close(master_sd); } else if (cmd == TCP_CONN) { if ((lstn_sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) die("TCP Server: failed to create listener socket"); /* Construct listener address structure */ memset(&srv_addr, 0, sizeof(srv_addr)); srv_addr.sin_family = AF_INET; srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); srv_addr.sin_port = htons(tcp_port); /* Bind socket to address */ while (0 > bind(lstn_sd, (struct sockaddr *) &srv_addr, sizeof(srv_addr))) srv_addr.sin_port = htons(++tcp_port); /* Inform master about own IP addresses and listener port number */ get_ip_list(&sinfo, NULL); sinfo.tcp_port = htons(tcp_port); printf("****** TCP Listener Socket Created ******\n"); srv_to_master(SRV_INFO, &sinfo); close(master_sd); } else { close(master_sd); goto reset; } /* Listen for incoming connections */ if (listen(lstn_sd, 32) < 0) die("Server: listen() failed"); while (1) { if (waitpid(-1, NULL, WNOHANG) > 0) { if (--srv_cnt) continue; close(lstn_sd); printf("****** Listener Socket Deleted ******\n"); goto reset; } peer_sd = wait_for_connection(lstn_sd); if (!peer_sd) continue; srv_id++; srv_cnt++; if (fork()) { close(peer_sd); continue; } /* Continue in child process */ close(lstn_sd); dprintf("calling echo: peer_sd: %u, srv_cnt = %u\n",peer_sd, srv_cnt); master_sd = socket(AF_TIPC, SOCK_RDM, 0); if (master_sd < 0) die("Server: Can't create socket to master\n"); if (bind(master_sd, (struct sockaddr *)&srv_ctrl_addr, sizeof(srv_ctrl_addr))) die("Server: Failed to bind to master socket\n"); echo_messages(peer_sd, master_sd, srv_id); } close(lstn_sd); printf("****** TIPC Benchmark Server Finished ******\n"); exit(0); return 0; }
void start_server(krb5_context context, const char *port_str) { int e; struct kadm_port *p; krb5_socket_t *socks = NULL, *tmp; unsigned int num_socks = 0; int i; if (port_str == NULL) port_str = "+"; parse_ports(context, port_str); for(p = kadm_ports; p; p = p->next) { struct addrinfo hints, *ai, *ap; char portstr[32]; memset (&hints, 0, sizeof(hints)); hints.ai_flags = AI_PASSIVE; hints.ai_socktype = SOCK_STREAM; e = getaddrinfo(NULL, p->port, &hints, &ai); if(e) { snprintf(portstr, sizeof(portstr), "%u", p->def_port); e = getaddrinfo(NULL, portstr, &hints, &ai); } if(e) { krb5_warn(context, krb5_eai_to_heim_errno(e, errno), "%s", portstr); continue; } i = 0; for(ap = ai; ap; ap = ap->ai_next) i++; tmp = realloc(socks, (num_socks + i) * sizeof(*socks)); if(tmp == NULL) { krb5_warnx(context, "failed to reallocate %lu bytes", (unsigned long)(num_socks + i) * sizeof(*socks)); continue; } socks = tmp; for(ap = ai; ap; ap = ap->ai_next) { krb5_socket_t s = socket(ap->ai_family, ap->ai_socktype, ap->ai_protocol); if(rk_IS_BAD_SOCKET(s)) { krb5_warn(context, rk_SOCK_ERRNO, "socket"); continue; } socket_set_reuseaddr(s, 1); socket_set_ipv6only(s, 1); if (rk_IS_SOCKET_ERROR(bind (s, ap->ai_addr, ap->ai_addrlen))) { krb5_warn(context, rk_SOCK_ERRNO, "bind"); rk_closesocket(s); continue; } if (rk_IS_SOCKET_ERROR(listen (s, SOMAXCONN))) { krb5_warn(context, rk_SOCK_ERRNO, "listen"); rk_closesocket(s); continue; } socks[num_socks++] = s; } freeaddrinfo (ai); } if(num_socks == 0) krb5_errx(context, 1, "no sockets to listen to - exiting"); wait_for_connection(context, socks, num_socks); }
/********************************************************************************************* * appMain() * * * *********************************************************************************************/ void appMain() { uint8 err, i,count; #ifdef FIRST_TIME_RUN //this is temporary arrangement. Ist_run_config(); //FIRST_TIME_CONNECTION_SETTING_PROFILES #endif wait_for_connection(); err= open_txPort_Mgr(); if(err) { //fatal error , failed to open socket with mgr. // restart . fatal(); } err= open_rxPort_Mgr(); if(err) { //fatal error , failed to open socket with mgr. // restart . fatal(); } err= setsockopt_rcv_timeout( 10000 ); if(err){ fatal(); } for( i=15; i>0;i--) { if(i>10) count = 20; else count = 1*i; toggleLed(SYSLED1); while(count--) __delay_cycles( 400000); //turnLedOn(SYSLED1); //__delay_cycles( 30000000); } turnLedOn(SYSLED1); __delay_cycles(62000000); test_send_data_to(2); // register_Me(); //TODO: this need to be substituted with registration related functions, which will be probably triggered on button press. //Infinite loop. while(1) { turnLedOff(SYSLED1); #ifdef TEST_SOCKET_RECEIVE test_rcv_data(); #else Execute_Mgr_Cmd(); #endif turnLedOn(SYSLED1); __delay_cycles(22000000); } // return; }