int main(int argc, char *argv[]) { #if defined(__NR_accept4) || defined(__NR_socketcall) struct sockaddr_in conn_addr; int lfd; int port_num; setup(); port_num = (argc > 1) ? atoi(argv[1]) : PORT_NUM; memset(&conn_addr, 0, sizeof(struct sockaddr_in)); conn_addr.sin_family = AF_INET; conn_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); conn_addr.sin_port = htons(port_num); lfd = create_listening_socket(port_num); do_test(lfd, &conn_addr, 0, 0); do_test(lfd, &conn_addr, SOCK_CLOEXEC, 0); do_test(lfd, &conn_addr, 0, SOCK_NONBLOCK); do_test(lfd, &conn_addr, SOCK_CLOEXEC, SOCK_NONBLOCK); close(lfd); #else tst_resm(TCONF, "syscall __NR_accept4 not supported on your arch"); #endif cleanup(); tst_exit(); }
int main() { fd_set read_fds; create_listening_socket(); printf("<?xml version='1.0' encoding='UTF-8'?>\n" ); printf( "<log>\n\n" ); /* Logging loop */ while( 1 ) { FD_ZERO(&read_fds); FD_SET(listening_socket, &read_fds); FD_SET(0, &read_fds); select(listening_socket+1, &read_fds, NULL, NULL, NULL); if (FD_ISSET(listening_socket, &read_fds)) receive_and_log_packet(); else break; } printf( "</log>\n" ); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { struct sockaddr_in conn_addr; int lfd; int port_num; setup(); port_num = (argc > 1) ? atoi(argv[1]) : PORT_NUM; memset(&conn_addr, 0, sizeof(struct sockaddr_in)); conn_addr.sin_family = AF_INET; conn_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); conn_addr.sin_port = htons(port_num); lfd = create_listening_socket(port_num); do_test(lfd, &conn_addr, 0, 0); do_test(lfd, &conn_addr, SOCK_CLOEXEC, 0); do_test(lfd, &conn_addr, 0, SOCK_NONBLOCK); do_test(lfd, &conn_addr, SOCK_CLOEXEC, SOCK_NONBLOCK); close(lfd); cleanup(); tst_exit(); }
static void init(void) { init_winsock(); create_io_completion_port(); create_listening_socket(); bind_listening_socket(); start_listening(); load_accept_ex(); start_accepting(); }
bool server_start(server_t server) { debug("starting the server\n"); server->free_chain = NULL; server->used_chain = NULL; server->listener = create_listening_socket(server->host, server->port); if (server->listener == -1) { return false; } return server_add_socket(server, server->listener, NULL); }
int setup_transport(EV_P_ transport *xprt) { int accept_fd = create_listening_socket(xprt->port); accept_watcher_data *awd = calloc(1, sizeof(accept_watcher_data)); awd->accept_fd = accept_fd; awd->xprt = xprt; awd->uniq_id = 0; ev_io *new_connection_watcher = malloc(sizeof(ev_io)); new_connection_watcher->data = awd; ev_io_init(new_connection_watcher, conn_accept_cb, accept_fd, EV_READ); xprt->xprt_initialize(xprt); ev_io_start(EV_DEFAULT_ new_connection_watcher); }
static int create_sockets_tcp(fd_pair *client_fds, fd_pair *server_fds) { int listen_fd = -1; int client_fd = -1; int server_fd = -1; struct sockaddr_in port; struct sockaddr *sa_port = (struct sockaddr *)&port; port.sin_family = AF_INET; port.sin_port = 0; port.sin_addr.s_addr = INADDR_ANY; listen_fd = create_listening_socket(sa_port, sizeof(port)); if (listen_fd == -1) { gpr_log(GPR_ERROR, "Listen failed"); goto error; } client_fd = connect_client(sa_port, sizeof(port)); if (client_fd == -1) { gpr_log(GPR_ERROR, "Connect failed"); goto error; } server_fd = accept_server(listen_fd); if (server_fd == -1) { gpr_log(GPR_ERROR, "Accept failed"); goto error; } client_fds->read_fd = client_fd; client_fds->write_fd = client_fd; server_fds->read_fd = server_fd; server_fds->write_fd = server_fd; close(listen_fd); return 0; error: if (listen_fd != -1) { close(listen_fd); } if (client_fd != -1) { close(client_fd); } if (server_fd != -1) { close(server_fd); } return -1; }
int ip_init() { set_my_ipaddr(); set_real_ip_addresses(); create_sending_socket(); create_listening_socket(); check_packet_logging(); packet_loss = get_percentage_env("PACKET_LOSS"); packet_corruption = get_percentage_env("PACKET_CORRUPTION"); if (my_ipaddr) return 1; return 0; }
bool server_start(server_t server) { debug("starting the server\n"); server->streamsnum = 0; server->listener = create_listening_socket(server->host, server->port); if (server->listener == -1) { return false; } FD_ZERO(&server->all); FD_SET(server->listener, &server->all); server->maxfd = server->listener; return true; }
int main(int argc, char* argv[]) { int one=1; int cmd=0; if(!IOFlashStorage_kernel_patch()) return -1; CFMutableDictionaryRef dict = FSDGetInfo(1); if(dict == NULL) { fprintf(stderr, "FAILed to get NAND infos"); return -1; } check_special_pages(); int sl = create_listening_socket(LISTEN_PORT); if(sl == -1) { fprintf(stderr, "Error calling create_listening_socket\n"); return -1; } fprintf(stderr, "NAND dumper listening on port %d\n", LISTEN_PORT); while(1) { int s = accept(sl, NULL, NULL); setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&one, sizeof(int)); int r = read(s, (void*) &cmd, sizeof(int)); if(r == sizeof(int)) { if(cmd == CMD_DUMP) { nand_dump(s); } else if(cmd == CMD_PROXY) { nand_proxy(s); } } shutdown(s, SHUT_RDWR); close(s); } return 0; }
int main(int argc, char ** argv) { server_state_t * s; // All of these setup routines may exit with an error. s = parse_args(argc, argv); create_listening_socket(s); open_backing_store(s); if (s->daemonize) { if (daemon(false, false) == -1) perror("daemon() failed"); } do_server(s); return 0; }
int main(int argc, char *argv[]) { int server_sock; int client_sock; if (argc < 2) { errx(1, "Please enter socket parameter!"); } signal(SIGPIPE, SIG_IGN); setlinebuf(stdout); server_sock = create_listening_socket(argv[1]); do { client_sock = accept_conn(server_sock); } while (read_write_loop(client_sock, stdout) != -1); return (0); }
static bool start_server(void) { int i; server.listener = -1; server.raftsock = -1; FD_ZERO(&server.all); server.maxfd = 0; server.clientnum = 0; server.listener = create_listening_socket(server.host, server.port); if (server.listener == -1) { return false; } for (i = 0; i < MAX_CLIENTS; i++) { server.clients[i].sock = -1; } return add_socket(server.listener); }
int main(int argc, char **argv) { int o; int port = 7667; gettimeofday(&prog_start, NULL); bzero(&PS, sizeof(PS)); PS.max_packets_on_the_wire = 1000000; PS.program_version = 2014052300; while ( (o = getopt(argc, argv, "hp:q")) != -1) { switch (o) { case 'h': usage(NULL); break; case 'p': port = strtol(optarg, NULL, 10); break; case 'q': opt_quiet = 1; break; default: usage(""); } } argc -= optind; argv += optind; if (argc != 0) usage("extraneous arguments"); create_snmp_socket(); create_listening_socket(port); event_loop(); return 0; }
/* * Main program. */ int main(int argc, char *argv[]) { #ifdef __linux__ // signal handling if (init_signal() < 0) exit(EXIT_FAILURE); // command line options checking if (check_args(argc, argv) < 0) exit(EXIT_FAILURE); // creating listening TCP socket listenfd = create_listening_socket(); if (listenfd < 0) exit(EXIT_FAILURE); // creating RAW socket rawfd = create_raw_socket(); if (rawfd < 0) exit(EXIT_FAILURE); // setting fds to select fd_set readfds; int select_ret; // infinite loop where select chooses one of listening or raw socket to serve while (keep_going) { FD_ZERO(&readfds); FD_SET(rawfd, &readfds); FD_SET(listenfd, &readfds); select_ret = select(MAX(rawfd, listenfd) + 1, &readfds, NULL, NULL, NULL); if (select_ret == -1) { // just cleaning up and finishing with error clean_up(); exit(EXIT_FAILURE); } else { // FD was choosen if (FD_ISSET(listenfd, &readfds)) { // incoming client if (add_client() < 0) { clean_up(); exit(EXIT_FAILURE); } } if (FD_ISSET(rawfd, &readfds)) { // reading from raw socket if (read_raw_socket() < 0) { clean_up(); exit(EXIT_FAILURE); } } } // if (select_ret > 0) } // while(keep_doing) // closing sockets if (clean_up() < 0) exit(EXIT_FAILURE); #endif exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { int ret, size; int fd = -1, fdv = -1, ls; struct input_event ev; struct pollfd fds[3]; int num_fds = 0; struct sigaction sa_int; /* * initialize our state */ daemonize(argv[0]); #ifdef DEBUG_PRINT console = fopen("/dev/console", "w"); if(console == NULL) exit(1); #endif if (sound_connect()) goto fail_sound; running = 0; if (backlight_connect() == 0) backlight = 1; fd = open_input_device("LF1000 Keyboard"); if (fd < 0) { dbprintf("can't open input device\n"); goto fail_kb; } fds[LFD_KEY_PRESS].fd = fd; fds[LFD_KEY_PRESS].events = POLLIN; num_fds++; /* volume fd open */ fdv = open_input_device("OpenLF Didj volume interface"); if (fdv < 0) { dbprintf("can't open volume input device\n"); goto fail_kb; } fds[LFD_VOLUME].fd = fdv; fds[LFD_VOLUME].events = POLLIN; num_fds++; ls = create_listening_socket(LFD_SOCKET_PATH); if (ls < 0) { dbprintf("can't create listening socket\n"); goto fail_sock; } fcntl(ls, F_SETFL, O_NONBLOCK); fds[LFD_CONTROL_SOCKET].fd = ls; fds[LFD_CONTROL_SOCKET].events = POLLIN; num_fds++; mv = battery_get_mv(); /* * trap SIGTERM so that we clean up before exiting */ running = 1; sigemptyset(&sa_int.sa_mask); sa_int.sa_handler = handle_signal; sa_int.sa_flags = 0; if (sigaction(SIGTERM, &sa_int, NULL) == -1) { dbprintf("can't trap SIGTERM\n"); goto fail_sig; } if (sigaction(SIGINT, &sa_int, NULL) == -1) { dbprintf("can't trap SIGINT\n"); goto fail_sig; } /* * monitor */ while (running) { ret = poll(fds, num_fds, 1000); if (ret == 0) { /* timeout */ mv = battery_get_mv(); } else if (ret > 0) { if (fds[LFD_KEY_PRESS].revents & POLLIN) { size = read(fd, &ev, sizeof(ev)); if (ev.type == EV_KEY && ev.value == 1) handle_key(ev.code); } if(fds[LFD_VOLUME].revents & POLLIN) { size = read(fdv, &ev, sizeof(ev)); if (ev.type == EV_ABS) handle_volume(ev.value); } if (fds[LFD_CONTROL_SOCKET].revents & POLLIN) handle_control_socket(ls); } } dbprintf("exiting...\n"); close(ls); close(fd); sound_disconnect(); #ifdef DEBUG_PRINT fclose(console); #endif exit(0); fail_sig: close(ls); fail_sock: fail_sound: close(fd); close(fdv); fail_kb: sound_disconnect(); #ifdef DEBUG_PRINT fclose(console); #endif exit(1); }
int socket_server_run() { int listen_fd, connect_fd; struct sockaddr_in client_addr; socklen_t client_len; if((listen_fd = create_listening_socket()) == -1) { fprintf(stderr, "can't create listening socket\n"); return -1; } FILE* log_file; log_file = open_log_file(); bool main_server_has_error = false; #ifdef __DEBUG__ fprintf(stdout, "start listening\n"); #endif if(signal(SIGCHLD, sig_chld) == SIG_ERR) { fprintf(stderr, "can't bind signal handler\n"); main_server_has_error = true; } while(main_server_has_error == false) { client_len = sizeof(client_addr); if((connect_fd = Accept(listen_fd, (SA*)&client_addr, &client_len)) == -1) { fprintf(stderr, "accept error\n"); main_server_has_error = true; break; } if(fork() == 0) // child process { int child_server_status = 0; FILE* read_file; FILE* write_file; if(close(listen_fd) == -1) { fprintf(stderr, "server child close listening socket error\n"); child_server_status = -1; } if((read_file = fdopen(connect_fd, "r+")) == NULL) { fprintf(stderr, "convertion from connected socket fd to FILE struct has error\n"); close(connect_fd); child_server_status = -1; } else { write_file = read_file; // socket is duplex #ifdef __DEBUG__ fprintf(stdout, "establish client server socket connection\n"); #endif if(run_server_core(read_file, write_file, open_log_file()) == -1) { fprintf(stderr, "server core has error\n"); child_server_status = -1; } //disconnect client socket is duplex, so read_file and write_file is the same file if(fclose(read_file) == EOF) { fprintf(stderr, "close the read file occurs an error\n"); child_server_status = -1; } if(log_file != NULL) { fclose(log_file); } } return child_server_status; } if(close(connect_fd) == -1) { fprintf(stderr, "server close connected socket error\n"); return -1; } } // you go here means you have something wrong if(close(listen_fd) == -1) { fprintf(stderr, "server child close listening socket error\n"); } if(log_file != NULL) { fclose(log_file); } return -1; }
int main(int argc, char *argv[]) { int ch, forkres, dontfork = 0, cpf; char conffile[PATH_MAX + 1]; strlcpy(conffile, CONFFILE, sizeof(conffile)); while((ch = getopt(argc, argv, "c:dDfhp:W")) != -1) switch(ch) { case 'c': strlcpy(conffile, optarg, sizeof(conffile)); break; case 'D': debug_f = 1; break; case 'd': dont_catch = 1; break; case 'f': dontfork = 1; break; case 'p': if ((command_port = atoi(optarg)) < 1) { print_usage(argv[0]); return EXIT_FAILURE; } break; case 'W': warn_f = 1; break; case 'h': default: print_usage(argv[0]); return EXIT_FAILURE; break; } cpf = conf_parsefile(conffile); if (cpf < 0 && strcmp(conffile, CONFFILE)) { fatalp("Cannot parse config file: %s\n", conffile); return EXIT_FAILURE; } else if (cpf > 0) { fatalp("Cannot parse line %d in config file\n", cpf); return EXIT_FAILURE; } if (set_my_ldp_id()) { fatalp("Cannot set LDP ID\n"); return EXIT_FAILURE; } if (conf_ldp_id.s_addr != 0) strlcpy(my_ldp_id, inet_ntoa(conf_ldp_id), INET_ADDRSTRLEN); if (mplssockaddr.sa_len == 0) { fatalp("FATAL: Create an mpls interface using ifconfig\n" "e.g. ifconfig mpls0 create up\n"); return EXIT_FAILURE; } if (mpls_start_ldp() == -1) return EXIT_FAILURE; if (!strcmp(LDP_ID, "0.0.0.0")) { fatalp("Cannot set my LDP ID.\nAre you sure you've " "got a non-loopback INET interface UP ?\n"); return EXIT_FAILURE; } init_command_sockets(); if ((command_socket = create_command_socket(command_port)) < 1) { fatalp("Cannot create command socket\n"); return EXIT_FAILURE; } if (create_hello_sockets() != 0) { fatalp("Cannot create hello socket\n"); return EXIT_FAILURE; } ls = create_listening_socket(); if (ls < 0) { fatalp("Cannot create listening socket\n"); return EXIT_FAILURE; } if (dontfork == 1) return the_big_loop(); forkres = fork(); if (forkres == 0) { syslog_f = 1; return the_big_loop(); } if (forkres < 0) perror("fork"); return EXIT_SUCCESS; }
int main(int argc, char ** argv) { fd_set readset; server_state_t * s; s = (server_state_t *)calloc(1, sizeof(server_state_t)); s->live_count = 0; s->total_count = 0; parse_args(argc, argv, s); /* open shared memory file */ if ((s->shm_fd = shm_open(s->shmobj, O_CREAT|O_RDWR, S_IRWXU)) < 0) { fprintf(stderr, "ivshmem server: could not open shared file\n"); exit(-1); } if (ftruncate(s->shm_fd, s->shm_size) != 0) { fprintf(stderr, "ivshmem server: could not truncate memory region\n"); exit(-1); } s->conn_socket = create_listening_socket(s->path); s->maxfd = s->conn_socket; for(;;) { int ret, handle, i; char buf[1024]; print_vec(s, "vm_sockets"); FD_ZERO(&readset); /* conn socket is in Live_vms at posn 0 */ FD_SET(s->conn_socket, &readset); for (i = 0; i < s->total_count; i++) { if (s->live_vms[i].alive != 0) { FD_SET(s->live_vms[i].sockfd, &readset); } } printf("\nWaiting (maxfd = %d)\n", s->maxfd); ret = select(s->maxfd + 1, &readset, NULL, NULL, NULL); if (ret == -1) { perror("select()"); } handle = find_set(&readset, s->maxfd + 1); if (handle == -1) continue; if (handle == s->conn_socket) { printf("[NC] new connection\n"); FD_CLR(s->conn_socket, &readset); /* The Total_count is equal to the new guests VM ID */ add_new_guest(s); /* update our the maximum file descriptor number */ s->maxfd = s->live_vms[s->total_count - 1].sockfd > s->maxfd ? s->live_vms[s->total_count - 1].sockfd : s->maxfd; s->live_count++; printf("Live_count is %ld\n", s->live_count); } else { /* then we have received a disconnection */ int recv_ret; long i, j; long deadposn = -1; recv_ret = recv(handle, buf, 1, 0); printf("[DC] recv returned %d\n", recv_ret); /* find the dead VM in our list and move it do the dead list. */ for (i = 0; i < s->total_count; i++) { if (s->live_vms[i].sockfd == handle) { deadposn = i; s->live_vms[i].alive = 0; close(s->live_vms[i].sockfd); for (j = 0; j < s->msi_vectors; j++) { close(s->live_vms[i].efd[j]); } free(s->live_vms[i].efd); s->live_vms[i].sockfd = -1; break; } } for (j = 0; j < s->total_count; j++) { /* update remaining clients that one client has left/died */ if (s->live_vms[j].alive) { printf("[UD] sending kill of fd[%ld] to %ld\n", deadposn, j); sendKill(s->live_vms[j].sockfd, deadposn, sizeof(deadposn)); } } s->live_count--; /* close the socket for the departed VM */ close(handle); } } return 0; }