void ClientConnectionSocket::connection_handle() { if (conn_receive() == -1) return; struct MSG_AckConnectPort* ack = (struct MSG_AckConnectPort*)_rxfifo.get_out(); int last_len = 0; struct MSG_IdentifyConnection* identify = (struct MSG_IdentifyConnection*)_rxfifo.get_out(); struct CMD_ClosePort * closeport = (struct CMD_ClosePort*)_rxfifo.get_out(); do { last_len = _rxfifo.len(); switch (_rxfifo.get_out()[0]) { case MSG_ACK_CONNECT_PORT: printf("Ack connect port: %d\n", ack->id); _rxfifo.skip( sizeof(struct MSG_AckConnectPort) ); break; case MSG_SOCKET_DATA: conn_socket_data(*this); break; case MSG_IDENTIFY_CONNECTION: { int bufsize = identify->len - sizeof(struct MSG_IdentifyConnection) + 1; if (_rxfifo.len() < identify->len) break; printf("bufsize:%d\n", bufsize); _name.assign((char*)identify + sizeof(struct MSG_IdentifyConnection), bufsize-1); printf("len:%d \"%s\"\n", identify->len, _name.c_str()); _rxfifo.skip(identify->len); if ( _name == "CLIENT1") { int server_sockfd = create_server_socket("8080"); new ForwardListenSocket(server_sockfd, 80, this); } if (_name == "CLIENT2") { int server_sockfd = create_server_socket("2222"); new ForwardListenSocket(server_sockfd, 22, _parent); } break; } case CMD_CLOSE_PORT: { printf("CMD_CLOSE_PORT id:%d\n", closeport->id); conn_from_id(closeport->id).connlist_delete(); _rxfifo.skip( sizeof(*closeport) ); } break; default: printf("Invalid package\n"); break; } } while (last_len != _rxfifo.len() && _rxfifo.len()); }
int main() { int server_sockfd = create_server_socket("12345"); new ServerDaemonSocket(server_sockfd); eventloop(); }
void server_main() { struct sigaction sa; int sock; sock_path = get_socket_path(); sock = create_server_socket(sock_path); if (sock == -1) { fprintf(stderr, "Error! Failed to create a server socket: %s\n", sock_path->data); exit(1); } sa.sa_handler = handle_sigint; sa.sa_flags = 0; sigaction(SIGINT, &sa, 0); clang_index = clang_createIndex(0, 0); server_loop(sock); if (clang_tu) clang_disposeTranslationUnit(clang_tu); clang_disposeIndex(clang_index); close(sock); unlink(sock_path->data); str_free(sock_path); }
/* init server * prepare for the db and get ready for connetions */ int server_init() { /* data intialization */ key_dict = dict_create(INIT_DICT_SIZE); if(NULL == key_dict) return E_MEM_OUT; _curr_request = malloc(sizeof(struct request) + IN_BUF_SIZE); if(NULL == _curr_request) return E_MEM_OUT; _curr_reply = malloc(sizeof(reply_t) + MAX_RPLY_SIZE); if(NULL == _curr_reply) return E_MEM_OUT; _action_head.next = _action_head.prev = &_action_head; if(NULL == (_time_bss = bss_create_empty(TIME_LEN))) return E_MEM_OUT; /* network initialization */ _listening_fd = create_server_socket(SERVER_PORT, MAX_QUEUED); if(E_NET_ERR == _listening_fd) return E_NET_ERR; if(-1 == (_efd = epoll_create1(0))) return E_UNKNOWN; return 0; }
int main(int argc, char **argv) { int maxsock,sockfd,sock_auth; unsigned int myport,listnum; fd_set fdsr; struct timeval tv; char *url = "OK OK"; int ret; myport = DEF_LISTEN_PORT; // listnum = 10; listnum = SOMAXCONN; if(argc > 1) { myport = atoi(argv[1]); } if(myport <= 0 ) { printf("%s invalid paramters!\n",argv[0]); return 0; } sockfd = create_server_socket(myport,listnum); if(sockfd == -1) { return 0; } maxsock = sockfd; LDEBUG("%s start to listen\n",argv[0]); while(1) { //init file desc set FD_ZERO(&fdsr); FD_SET(sockfd, &fdsr); // timeout setting tv.tv_sec = 30; tv.tv_usec = 0; ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv); if(ret < 0) { printf("select error"); break; } else if(ret == 0) { LDEBUG("timeout\n"); continue; } if(FD_ISSET(sockfd, &fdsr)) { handleRequest(sockfd,url); } } return 0; }
int main() //@ : main_full(MockKernel) //@ requires module(MockKernel, true); //@ ensures true; { struct server_socket *serverSocket = 0; //@ open_module(); //@ int modulesId = create_ghost_set<struct module *>(); //@ int devicesId = create_ghost_set<struct device *>(); //@ close lseg(0, 0, nil, kernel_module(modulesId, devicesId)); //@ close lseg(0, 0, nil, device(modulesId, devicesId)); //@ close kernel_inv(modulesId, devicesId)(); //@ close create_lock_ghost_args(kernel_inv(modulesId, devicesId), nil, nil); kernelLock = create_lock(); //@ assert pointer(&kernelLock, ?kernelLock_); //@ leak pointer(&kernelLock, kernelLock_); //@ leak lock(kernelLock_, _, kernel_inv(modulesId, devicesId)); serverSocket = create_server_socket(12345); while (true) //@ invariant [_]pointer(&kernelLock, kernelLock_) &*& [_]lock(kernelLock_, _, kernel_inv(modulesId, devicesId)) &*& server_socket(serverSocket); { struct socket *socket = server_socket_accept(serverSocket); //@ close kernel_inv_info(modulesId, devicesId); //@ close thread_run_data(handle_connection)(socket); thread_start(handle_connection, socket); } }
int main(int argc, char **argv) { int server_sock; int client_sock; pthread_t thread_id; struct thread_args_t *thread_args; server_sock = create_server_socket(SERVERPORT); for (;;) { client_sock = accept_connection(server_sock); // Create separate memory for client argument if ((thread_args = (struct thread_args_t *)malloc(sizeof(struct thread_args_t))) == 0) die_with_error("malloc() failed"); thread_args->client_sock = client_sock; // Create client thread if (pthread_create(&thread_id, 0, thread_main, (void *)thread_args) != 0) die_with_error("pthread_create() failed"); printf("...with thread %lu\n", (unsigned long)thread_id); } /* This point is never reached. */ return 0; }
int main(int argc, char* argv[]) { // check input data if (argc < 4) { printf("usage: cproxy [-u] <host> <port> <host> <port>\n"); return -1; } int protocol; char* hostname_from; int port_from; char* hostname_to; int port_to; if (strcmp(argv[1], "-u") == 0) { protocol = IPPROTO_UDP; hostname_from = argv[2]; port_from = atoi(argv[3]); hostname_to = argv[4]; port_to = atoi(argv[5]); } else { protocol = IPPROTO_TCP; hostname_from = argv[1]; port_from = atoi(argv[2]); hostname_to = argv[3]; port_to = atoi(argv[4]); } // not buffering stdout setbuf(stdout, NULL); // create sockets int socket_fd_server = create_server_socket(protocol, hostname_from, port_from); if (socket_fd_server < 0) { return -1; } printf("\n"); int socket_fd_client = create_client_socket(protocol, hostname_to, port_to); if (socket_fd_client < 0) { return -1; } // create proxy if (protocol == IPPROTO_TCP) { if (create_tcp_proxy(socket_fd_server, socket_fd_client) < 0) { return -1; } } else { if (create_udp_proxy(socket_fd_server, socket_fd_client) < 0) { return -1; } } return 0; }
int server_start() { thread_state_t *state = NULL; struct sockaddr_in cli_addr; int cli_fd; socklen_t clilen = sizeof (cli_addr); /* Allocate new configuration */ if ((server_config = config_new()) == NULL) { ERROR_MSG("Internal error: Can not allocate configuration\n"); return 1; } /* Creating socket */ if ((server_config->socket_fd = create_server_socket(get_port())) < 0) { ERROR_MSG("Error: Can not create socket\n"); config_free(&server_config); return 1; } while (1) { cli_fd = accept(server_config->socket_fd, (struct sockaddr *)&cli_addr, &clilen); if (cli_fd < 0) { ERROR_MSG("ERROR on accept\n"); continue; } if (check_overload() < 0) { ERROR_MSG("ERROR close\n"); close(cli_fd); continue; } state = thread_state_new(); state->cli_fd = cli_fd; INCR_SERVER_LOAD; pthread_create(&(state->thread), NULL, compile_file, state); } config_free(&server_config); return 0; }
int main(int argc, char *argv[]) { if ( argc != 2 ) error("usage: server port"); short port = atoi(argv[1]); int server_socket = create_server_socket(port); accept_client_requests(server_socket); shutdown(server_socket, 2); return 0; }
int init_udprelay(const char *server_host, const char *server_port, #ifdef MODULE_LOCAL const struct sockaddr *remote_addr, const int remote_addr_len, #ifdef MODULE_TUNNEL const ss_addr_t tunnel_addr, #endif #endif int mtu, crypto_t *crypto, int timeout, const char *iface) { // Initialize ev loop struct ev_loop *loop = EV_DEFAULT; // Initialize MTU if (mtu > 0) { packet_size = mtu - 1 - 28 - 2 - 64; buf_size = packet_size * 2; } // Initialize cache struct cache *conn_cache; cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb); // //////////////////////////////////////////////// // Setup server context // Bind to port int serverfd = create_server_socket(server_host, server_port); if (serverfd < 0) { FATAL("[udp] bind() error"); } setnonblocking(serverfd); server_ctx_t *server_ctx = new_server_ctx(serverfd); #ifdef MODULE_REMOTE server_ctx->loop = loop; #endif server_ctx->timeout = max(timeout, MIN_UDP_TIMEOUT); server_ctx->crypto = crypto; server_ctx->iface = iface; server_ctx->conn_cache = conn_cache; #ifdef MODULE_LOCAL server_ctx->remote_addr = remote_addr; server_ctx->remote_addr_len = remote_addr_len; #ifdef MODULE_TUNNEL server_ctx->tunnel_addr = tunnel_addr; #endif #endif ev_io_start(loop, &server_ctx->io); server_ctx_list[server_num++] = server_ctx; return serverfd; }
/* Run on bear */ int main(int argc, char const *argv[]) { signal(SIGPIPE, SIG_IGN); /* code */ int peer_main_socket = create_server_socket(PEER_PORT); pthread_t thread; pthread_create(&thread, NULL, peer_handler_multi_thread,&peer_main_socket); pthread_join(thread,NULL); return 0; }
void belle_sip_stream_listening_point_setup_server_socket(belle_sip_stream_listening_point_t *obj, belle_sip_source_func_t on_new_connection_cb ){ int port=belle_sip_uri_get_port(obj->base.listening_uri); obj->server_sock=create_server_socket(belle_sip_uri_get_host(obj->base.listening_uri), &port, &obj->base.ai_family); if (obj->server_sock==(belle_sip_socket_t)-1) return; belle_sip_uri_set_port(((belle_sip_listening_point_t*)obj)->listening_uri,port); if (obj->base.stack->dscp) belle_sip_socket_set_dscp(obj->server_sock,obj->base.ai_family,obj->base.stack->dscp); obj->source=belle_sip_socket_source_new(on_new_connection_cb,obj,obj->server_sock,BELLE_SIP_EVENT_READ,-1); belle_sip_main_loop_add_source(obj->base.stack->ml,obj->source); }
int udprelay_init(const char *server_host, const char *server_port, #ifdef UDPRELAY_LOCAL const char *remote_host, const char *remote_port, #ifdef UDPRELAY_TUNNEL const ss_addr_t tunnel_addr, #endif #endif #ifdef UDPRELAY_REMOTE asyncns_t *asyncns, #endif int method, int timeout, const char *iface) { // Inilitialize ev loop struct ev_loop *loop = EV_DEFAULT; // Inilitialize cache struct cache *conn_cache; cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb); ////////////////////////////////////////////////// // Setup server context // Bind to port int serverfd = create_server_socket(server_host, server_port); if (serverfd < 0) { FATAL("udprelay bind() error.."); } setnonblocking(serverfd); struct server_ctx *server_ctx = new_server_ctx(serverfd); server_ctx->timeout = timeout; server_ctx->method = method; server_ctx->iface = iface; server_ctx->conn_cache = conn_cache; #ifdef UDPRELAY_LOCAL server_ctx->remote_host = remote_host; server_ctx->remote_port = remote_port; #ifdef UDPRELAY_TUNNEL server_ctx->tunnel_addr = tunnel_addr; #endif #endif #ifdef UDPRELAY_REMOTE server_ctx->asyncns = asyncns; #endif ev_io_start(loop, &server_ctx->io); return 0; }
int main() { int port = 7680; int serversock; int clientsock; struct sockaddr_in clientname; size_t size = 0; char buffer[10000]; int received; char* cmd_step_into = "step_into"; char* cmd_step_over = "step_over"; char* cmd_step_out = "step_out"; char* cmd_continue = "continue"; char* cmd_top = "stop"; serversock = create_server_socket(port); if(listen(serversock, 1) < 0) { //1: queue size for receiving connections printf("server: error listening\n"); exit(EXIT_FAILURE); } printf("waiting...\n"); clientsock = accept(serversock, (struct sockaddr*) &clientname, &size); printf("server: connection accepted, addr size: %d\n", size); while(1) { printf("waiting for data...\n"); received = recv(clientsock, buffer, sizeof(buffer), 0); if(received < 0) { printf("error receiving\n"); exit(EXIT_FAILURE); } else if(received == 0) { printf("no data received\n"); break; } else { printf("total pack: %d, data received: \n>>>\n%s\n<<<\n", received, buffer +1+ (strlen(buffer)*sizeof(char))); } printf("\n\n"); if(send(clientsock, cmd_step_into, sizeof(char)* (strlen(cmd_step_into)+1), 0) < 0) {//error printf("client:error sending data\n"); break; } } shutdown(clientsock, SHUT_RDWR); shutdown(serversock, SHUT_RDWR); //CLOSE ALL close(clientsock); close(serversock); }
/* * Main master thread * * Continually loops, accepting connections. Uses the select() function to allow * for timeouts. */ void *master(void *arg) { struct context *ctx = arg; // Listen for incoming connections int server_sockfd = create_server_socket(ctx); if (listen(server_sockfd, BACKLOG) == -1) { perror("listen"); } // main accept() loop fd_set read_set; struct timeval timeout; int max_fd, ret_val; int stop = ctx->stop_pipe[0]; while (1) { FD_ZERO(&read_set); // update this if more fd's added to read set FD_SET(server_sockfd, &read_set); FD_SET(stop, &read_set); max_fd = MAX(server_sockfd, stop); timeout.tv_sec = 0; timeout.tv_usec = 200 * 1000; ret_val = select(max_fd + 1, &read_set, NULL, NULL, &timeout); if (ret_val < 0) { perror("server: select"); } else if (ret_val > 0) { // update this if more fd's are added to read set if (FD_ISSET(server_sockfd, &read_set)) { trace("%s\n", "accepting a connection"); accept_connection(server_sockfd, ctx); } else if (FD_ISSET(stop, &read_set)) { trace("%s\n", "Stopping"); break; } } } close(server_sockfd); trace("%s\n", "Master thread exiting"); pthread_mutex_lock(&ctx->mutex); ctx->num_threads--; pthread_cond_signal(&ctx->term); pthread_mutex_unlock(&ctx->mutex); return NULL; }
int init_udprelay(const char *server_host, const char *server_port, #ifdef UDPRELAY_LOCAL const struct sockaddr *remote_addr, const int remote_addr_len, #ifdef UDPRELAY_TUNNEL const ss_addr_t tunnel_addr, #endif #endif int method, int auth, int timeout, const char *iface) { // Inilitialize ev loop struct ev_loop *loop = EV_DEFAULT; // Inilitialize cache struct cache *conn_cache; cache_create(&conn_cache, MAX_UDP_CONN_NUM, free_cb); ////////////////////////////////////////////////// // Setup server context // Bind to port int serverfd = create_server_socket(server_host, server_port); if (serverfd < 0) { FATAL("[udp] bind() error"); } setnonblocking(serverfd); struct server_ctx *server_ctx = new_server_ctx(serverfd); #ifdef UDPRELAY_REMOTE server_ctx->loop = loop; #endif server_ctx->auth = auth; server_ctx->timeout = max(timeout, MIN_UDP_TIMEOUT); server_ctx->method = method; server_ctx->iface = iface; server_ctx->conn_cache = conn_cache; #ifdef UDPRELAY_LOCAL server_ctx->remote_addr = remote_addr; server_ctx->remote_addr_len = remote_addr_len; #ifdef UDPRELAY_TUNNEL server_ctx->tunnel_addr = tunnel_addr; #endif #endif ev_io_start(loop, &server_ctx->io); server_ctx_list[server_num++] = server_ctx; return 0; }
int main(int argc, char **argv) { signal(SIGCHLD, SIG_IGN); signal(SIGUSR1, SIG_IGN); test_mongo_connection(); int port = argc >= 2 ? atoi(argv[1]) : DEFAULT_PORT; int server = create_server_socket(port); while (1) { struct sockaddr cli_addr; int cli_len = sizeof(cli_addr); int client = accept(server, &cli_addr, &cli_len); if (client < 0) die("accept"); int pid = fork(); if (pid < 0) die("fork"); if (pid == 0) { if (dup2(client, STDIN_FILENO) < 0) die("dup2 stdin"); if (dup2(client, STDOUT_FILENO) < 0) die("dup2 stdout"); D(" [%d] process started\n", getpid()); if (db_connect() == 0) { process_client(); db_disconnect(); } else { WriteLn("DB connection problem, sorry"); D(" [%d] cannot connect to db\n", getpid()); } D(" [%d] process finished\n", getpid()); shutdown(client, 2); exit(0); } close(client); } close(server); return 0; }
static void check_port(GtkButton *button, gpointer user_data) { gchar *valore; valore = gtk_editable_get_chars(GTK_EDITABLE(port_entry), 0, -1); chat_port = atoi(valore); g_free(valore); if (chat_port) { serv_sock = create_server_socket(); if (serv_sock != -1) { gtk_widget_destroy(GTK_WIDGET(user_data)); gdk_input_add(serv_sock, GDK_INPUT_READ, input_func, NULL); } } }
/** * Creates a server socket (SOCK_STREAM type) and binds it to the * specified local port number. The socket get a ssl layer for * data transmission. * @param pemfilename Filename for the key/cert file * @param port The localhost port number to open * @param backlog The maximum queue length for incomming connections * @param bindAddr the local address the server will bind to * @return An ssl connection ready for accept, or NULL if an error occured. */ ssl_server_connection *create_ssl_server_socket(char *pemfile, int port, int backlog, char *bindAddr, char *clientpemfile) { #ifdef HAVE_OPENSSL int socket; ssl_server_connection *ssl_server; ASSERT(pemfile); ASSERT(bindAddr); if (!ssl_initilized) { start_ssl(); } if ((socket= create_server_socket(port, backlog, bindAddr)) == -1) { log("%s: create_ssl_server_socket(): Cannot connect!\n", prog); goto sslerror; } if (( ssl_server= init_ssl_server(pemfile, clientpemfile)) == NULL) { goto sslerror; } ssl_server->server_socket=socket; return ssl_server; sslerror: return NULL; #else return FALSE; #endif }
static int init_server(dtls_listener_relay_server_type* server, const char* ifname, const char *local_address, int port, int verbose, ioa_engine_handle e, turn_turnserver *ts) { if(!server) return -1; server->dtls_ctx = e->dtls_ctx; server->ts = ts; server->children_ss = ur_addr_map_create(65535); if(ifname) STRCPY(server->ifname,ifname); if(make_ioa_addr((const u08bits*)local_address, port, &server->addr)<0) { TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,"Cannot create a UDP/DTLS listener for address: %s\n",local_address); return -1; } server->slen0 = get_ioa_addr_len(&(server->addr)); server->verbose=verbose; server->e = e; TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"IO method: %s\n",event_base_get_method(server->e->event_base)); if(server->dtls_ctx) { #if defined(REQUEST_CLIENT_CERT) /* If client has to authenticate, then */ SSL_CTX_set_verify(server->dtls_ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, dtls_verify_callback); #endif SSL_CTX_set_read_ahead(server->dtls_ctx, 1); #if !defined(TURN_NO_DTLS) SSL_CTX_set_cookie_generate_cb(server->dtls_ctx, generate_cookie); SSL_CTX_set_cookie_verify_cb(server->dtls_ctx, verify_cookie); #endif } return create_server_socket(server); }
int main(int argc, char** argv) { if(argc!=2) { printf(ANSI_COLOR_BOLDRED "Cantidad erronea de parametros. Este proceso recibe un parametro \n" ANSI_COLOR_RESET); return EXIT_FAILURE; } /*Tratamiento del ctrl+c en el proceso */ if(signal(SIGINT, ifProcessDie) == SIG_ERR ) log_error(loggerError, ANSI_COLOR_RED"Error con la señal SIGINT"ANSI_COLOR_RESET); /*Se genera el struct con los datos del archivo de config.- */ char* path = argv[1]; crear_estructura_config(path); /*Se genera el archivo de log, to-do lo que sale por pantalla */ crearArchivoDeLog(); /*Se inicializan todos los semaforos necesarios */ inicializoSemaforos(); /*Se inicializan todos los semaforos necesarios */ creoEstructuraSwap(); socketServidor = create_server_socket(arch->puerto_escucha); int32_t resultado = listen_connections(socketServidor); if(resultado == ERROR_OPERATION) { log_error(loggerError, ANSI_COLOR_RED "Error al escuchar nuevas conexiones"ANSI_COLOR_RESET); exit(EXIT_FAILURE); } sock_t* socketCliente = accept_connection(socketServidor); log_debug(loggerDebug, "Memoria conectada"); recibir_operaciones_memoria(socketCliente); limpiar_estructuras_swap(); return EXIT_SUCCESS; }
int create_gateway(gateway_handle* handle, gateway_create_params *params) { gateway_context *gateway = NULL; int return_value = 0; gateway = (gateway_context*)malloc(sizeof(gateway_context)); if(NULL == gateway) { LOG_ERROR(("ERROR: Out of memory\n")); return (E_OUT_OF_MEMORY); } gateway->client_count = 0; /* create network read thread */ return_value = create_network_thread(&gateway->network_thread, params->gateway_ip_address); if(E_SUCCESS != return_value) { LOG_ERROR(("ERROR: Error in creating n/w read thread\n")); delete_gateway((gateway_handle)gateway); return (return_value); } /* create connection to server */ return_value = create_server_socket(&gateway->server_socket_fd, params->gateway_ip_address, params->gateway_port_no); if(E_SUCCESS != return_value) { LOG_ERROR(("ERROR: Error in creating the socket\n")); delete_gateway((gateway_handle)gateway); return (return_value); } /* add socket to network read thread */ return_value = add_socket(gateway->network_thread, gateway->server_socket_fd, (void*)gateway, &accept_callback); if(E_SUCCESS != return_value) { LOG_ERROR(("ERROR: add_socket() failed\n")); delete_gateway((gateway_handle)gateway); return (return_value); } *handle = gateway; return (E_SUCCESS); }
int main(){ void **value_ptr = NULL; short host_numbers[16]; short sockfd = create_server_socket(); int i; if(sockfd < 0){ printf("\n Arbiter Error. Arbiter closing ...\n"); return -1; } hostsockfd_init(); sigemptyset(&set); sigaddset(&set, SIGINT); pthread_sigmask(SIG_BLOCK, &set, NULL); //printf("\n Going to Signal Handling .....\n"); pthread_create(&signal_thread, 0, (void *)&signal_handler, &sockfd); open_log_files(); //printf("\n accept_connections thread ---------------\n"); pthread_create(&accept_connections_thread, 0, (void *)&accept_connections, &sockfd); //printf("\n get_demands thread -------------------"); for(i=0; i<16; i++){ host_numbers[i] = i+1; pthread_create(&recieve_request_thread[i], 0, (void *)&get_demands, &(host_numbers[i])); } //printf("\n process_demands thread ----------------------"); pthread_create(&process_request_thread, 0, (void *)&process_demands, NULL); // pthread_create(&send_response_thread, 0, (void *)&send_demands_to_host, NULL); //pthread_create(&send_response_thread, 0, (void *)&get_demands, NULL); pthread_join (accept_connections_thread, value_ptr); for(i=0; i<16; i++) pthread_join (recieve_request_thread[i], value_ptr); // pthread_join (process_request_thread, value_ptr); // pthread_join (send_response_thread, value_ptr); //close_log_files(); return 0; }
int main() //@ : main //@ requires true; //@ ensures false; { struct room *room = create_room(); //@ close room_ctor(room)(); //@ close create_lock_ghost_args(room_ctor(room), nil, nil); struct lock *roomLock = create_lock(); //@ leak lock(roomLock, _, _); struct server_socket *serverSocket = create_server_socket(12345); for (;;) //@ invariant [_]lock(roomLock, _, room_ctor(room)) &*& server_socket(serverSocket); { struct socket *socket = server_socket_accept(serverSocket); struct session *session = create_session(room, roomLock, socket); //@ close thread_run_data(session_run)(session); thread_start(session_run, session); } }
int main(int argc, char **argv) { if(argc != 2) { printf("***Usage: %s <port to bind>\n", argv[0]); return -1; } int port = atoi(argv[1]); char hostname[100] = {0,}; gethostname(hostname, 100); printf("***Proxy server(%s:%d) starting...\n", hostname, port); int sockfd_proxy = create_server_socket(port); main_loop(sockfd_proxy); return 0; }
static void do_tcp_server_start(void* userdata) { tcp_server_t *server = (tcp_server_t*)userdata; do { server->fd = create_server_socket(server->addr.port, server->addr.ip); if (server->fd < 0) { log_error("do_tcp_server_start: create_server_socket() failed, local addr: %s:%u", server->addr.ip, server->addr.port); break; } server->channel = channel_new(server->fd, server->loop, server_onevent, server); if (listen(server->fd, 512) != 0) { log_error("do_tcp_server_start: listen() failed, errno: %d, local addr: %s:%u", errno, server->addr.ip, server->addr.port); break; } if (channel_setevent(server->channel, EPOLLIN)) { log_error("do_tcp_server_start: channel_setevent() failed, local addr: %s:%u", server->addr.ip, server->addr.port); break; } return; } while(0); if (server->fd >= 0) { close(server->fd); server->fd = -1; } channel_destroy(server->channel); server->channel = NULL; server->is_started = 0; return; }
static void *pipe_thread(void*p) { char tmp[250]; server_sock=create_server_socket(); if (server_sock==ORTP_PIPE_INVALID) return NULL; while(pipe_reader_run) { while(client_sock!=ORTP_PIPE_INVALID) { /*sleep until the last command is finished*/ #ifndef WIN32 usleep(20000); #else Sleep(20); #endif } client_sock=ortp_server_pipe_accept_client(server_sock); if (client_sock!=ORTP_PIPE_INVALID) { int len; /*now read from the client */ if ((len=ortp_pipe_read(client_sock,(uint8_t*)tmp,sizeof(tmp)-1))>0) { ortp_mutex_lock(&prompt_mutex); tmp[len]='\0'; strcpy(received_prompt,tmp); printf("Receiving command '%s'\n",received_prompt); fflush(stdout); have_prompt=TRUE; ortp_mutex_unlock(&prompt_mutex); } else { printf("read nothing\n"); fflush(stdout); ortp_server_pipe_close_client(client_sock); client_sock=ORTP_PIPE_INVALID; } } else { if (pipe_reader_run) fprintf(stderr,"accept() failed: %s\n",strerror(errno)); } } ms_message("Exiting pipe_reader_thread."); fflush(stdout); return NULL; }
int connect_to_client() { // The socket on which the server receives // all incoming connections int server_socket; // The socket for unique communication with the client int client_socket; server_socket = create_server_socket(); client_socket = accept_client(server_socket); // Don't need the server socket anymore (only have one connection) // close(client_socket); if (fork() != (pid_t)0) { // Don't need the server socket anymore (only have one connection) close(client_socket); close(server_socket); exit(EXIT_SUCCESS); } return client_socket; }
int main() { calc_message_t* request; // Client's request message message_t* response; // Server response message host_t client; // Client's address // Create a socket to listen on port 5000 int sockfd = create_server_socket("5000"); // Read the request message and generate the response request = (calc_message_t*)receive_message(sockfd, &client); response = create_response_message(request); // Send the response and free the memory allocated to the messages send_message(sockfd, response, &client); free(request); free(response); // Close the socket close(sockfd); exit(EXIT_SUCCESS); }