int main (int argc, char **argv) { gsk_init_without_threads (&argc, &argv); g_printerr ("TCP/IP server/client... "); addr = gsk_socket_address_ipv4_localhost (10306); create_server (addr); client_count = 0; create_client (addr); while (!done_test) gsk_main_loop_run (gsk_main_loop_default(), -1, NULL); g_object_unref (listener); listener = NULL; g_object_unref (addr); addr = NULL; g_printerr (" done.\n"); client_count = 0; done_test = FALSE; g_printerr ("Local-socket server/client... "); #define TEST_LOCAL_SOCKET_FNAME "./test-socket-sc" addr = gsk_socket_address_local_new (TEST_LOCAL_SOCKET_FNAME); create_server (addr); client_count = 0; create_client (addr); while (!done_test) gsk_main_loop_run (gsk_main_loop_default(), -1, NULL); g_object_unref (listener); g_object_unref (addr); g_printerr (" done.\n"); return 0; }
/* static struct sigaction sa={ .sa_handler = SIG_IGN }; */ int server(int port, int maxevents) { // sigaction(SIGINT, &sa, 0); // sigaction(SIGTERM, &sa, 0); int srv_fd = -1; int epoll_fd = -1; reactor* r = 0; event_handler* seh = 0; if((srv_fd=create_server(port,"127.0.0.1")) == -1){ return -1; } if((epoll_fd = create_epoll(srv_fd, maxevents)) == -1){ return -1; } r = create_reactor(epoll_fd, maxevents); seh = create_acceptor(srv_fd, r); r->add_eh(r, seh); r->event_loop(r); destroy_reactor(r); os_close(srv_fd); os_close(epoll_fd); return 0; }
PortServer * create_port_server(Channel * c, PortAttribute * attrs, PortConnectCallback connect_callback, PortDisconnectCallback disconnect_callback, PortRecvCallback recv_callback, void * callback_data) { PortServer * server; assert (c != NULL); assert (attrs != NULL); if (c == NULL || attrs == NULL) { free_port_redirection_attrs(attrs); errno = EINVAL; return NULL; } ini_portforwarding(); server = create_server(c, attrs); if (server == NULL) { free_port_redirection_attrs(attrs); return NULL; } else { server->connect_callback = connect_callback; server->disconnect_callback = disconnect_callback; server->recv_callback = recv_callback; server->callback_data = callback_data; if (server->auto_connect) { /* If auto connect mode is set, immediately try to connect to the * port. */ if (server->auto_connect_period == 0) server->auto_connect_period = 3; port_connection_open(server, server->is_udp ? server->sock : -1); } return server; } }
int main() { int listenfd = create_server(2000), connfd, i, pid, ret; char line[1000]; pthread_t tid; struct request *r; for (; ;) { if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL))<0) { perror("accept error : "); return -1; } getline(line, connfd); if ((ret = validate_request(line, connfd))>0) { r = (struct request *)malloc(sizeof(struct request)); r->request_t = ret; strcpy(r->req, line); r->connfd = connfd; printf("creating thread\n"); ret = pthread_create(&tid, NULL, handle_request, (void *)r); } else { close(connfd); } } close(listenfd); return 0; }
int main(int argc, char *argv[]) { int sock; int cs; unsigned int cslen; struct sockaddr_in csin; pid_t pid; signal(SIGCHLD, SIG_IGN); if (argc != 2) usage(argv[0]); sock = create_server(ft_atoi(argv[1])); while ((cs = accept(sock, (struct sockaddr *)&csin, &cslen)) > 0) { if ((pid = fork()) == -1) return (-1); if (pid == 0) { soon(cs); exit(0); return (0); } } close(cs); close(sock); return (0); }
int main(int argc, char* argv[]) { int ret; // create server ret = create_server(); if(ret != 0) { printf("create server error\n"); return -1; } // send broad cast ret = send_broadcast(); if(ret != 0) { printf("send broadcast error\n"); return -2; } // accept client ret = accept_client(); if(ret != 0) { printf("accept_client error\n"); return -3; } return 0; }
void start_server(const char *ip, unsigned short port) { //signal(SIGPIPE, SIG_IGN); signal(SIGPIPE, sig_handler); create_sock_list(); start_timer(); int err = 0; // create a TCP socket, bind and listen server_sock = socket(AF_INET, SOCK_STREAM, 0); fcntl(server_sock, F_SETFL, O_NONBLOCK); struct sockaddr_in addr; memset(&addr, 0 , sizeof(addr)); addr.sin_family = AF_INET; //addr.sin_addr.s_addr = htons(INADDR_ANY); addr.sin_addr.s_addr = inet_addr(ip); addr.sin_port = htons(port); err = bind(server_sock, (struct sockaddr *) &addr, sizeof(addr)); if(err) { printf("bind error: %m\n"); } listen(server_sock, 10); g_server = create_server(server_sock); return 0; }
int main(int argc , char *argv[]) { int socket_desc; int * clients = malloc(sizeof(int) * 4); char buffer[32] = {0}; fd_set readfs; init_soft_war(); my_actopt(g_tab, 6, argc, argv); build_map(); show_info_server(); if (soft_war.type == 0) { socket_desc = create_server(soft_war.port); clients = accept_for_clients(socket_desc); put_clients_on_map(); while (1) { select_for_soft_war(clients, &readfs, buffer); } } else { play(argc, argv); } return (0); }
int main(int argc, char **argv) { signal(SIGINT, sigstop); signal(SIGQUIT, sigstop); signal(SIGTERM, sigstop); if ((fd_iav = open("/dev/iav", O_RDWR, 0)) < 0) { perror("open /dev/iav"); return -1; } if (init_param(argc, argv) < 0) { usage(); return -1; } parse_default_configs(); if (create_server() < 0) { APP_ERROR("create_server"); return -1; } main_handle(); #if 0 while (1) { main_loop(); } #endif while (1) { sleep(1); } return 0; }
int main(int argc, char *argv[]) { int server, port = PORT, opt_idx = 0, c; static struct option long_options[] = { { "debug", no_argument, &debug, 1 }, { "port", required_argument, 0, 'p' } }; while ((c = getopt_long(argc, argv, "p:", long_options, &opt_idx)) != -1) { switch (c) { case 'p': port = atoi(optarg); break; case '?': break; } } if ((server = create_server(port)) == -1) { return -1; } if (!debug) { daemon(0, 0); } accept_loop(server, handle_client); return 0; }
int main(){ signal(SIGINT, destroy_server); char server_path[BUFFER]; CREATE_SERVER_FIFO_NAME(server_path); create_server(); char* client_pid = NULL; char hack; long pid = 0; FILE* server_fd = fopen(server_path, "r+"); size_t len = 0; ssize_t read; while((read = getline(&client_pid, &len, server_fd)) != -1){ fread(&hack, sizeof(char), 1, server_fd); pid = strtol(client_pid, NULL, 10); if(fork() == 0){ printf("Creating server for Client %ld\n", pid); baby_server_read(pid); } if(signal(SIGINT, destroy_server) == SIG_ERR){ printf("Signal didn't work"); } } return 0; }
void BuildServer::onItemClicked( QTableWidgetItem *item ) { qDebug() << "BuildServer: onItemClicked and emit toBuildTCP()" ; IP = tableWidget->item( item->row() , 1 )->text() ; connect( this , SIGNAL( toBuildTCP() ) , peopVSpeop , SLOT( create_server() ) ) ; emit toBuildTCP() ; }
void ft_init(t_serv *e, char *av) { e->counter = 0; e->port = ft_atoi(av); e->sock = create_server(e->port); getcwd(e->home, 1024); e->pwd = ft_strdup(e->home); }
void do_sendfile(void) { int in_fd; struct stat sb; off_t after_pos; int wait_status; int wait_stat; out_fd = create_server(); if ((in_fd = open(in_file, O_RDONLY)) < 0) { tst_brkm(TBROK, cleanup, "open failed: %d", errno); } if (stat(in_file, &sb) < 0) { tst_brkm(TBROK, cleanup, "stat failed: %d", errno); } TEST(sendfile(out_fd, in_fd, NULL, sb.st_size)); if ((after_pos = lseek(in_fd, 0, SEEK_CUR)) < 0) { tst_brkm(TBROK, cleanup, "lseek after invoking sendfile failed: %d", errno); } if (STD_FUNCTIONAL_TEST) { /* Close the sockets */ shutdown(sockfd, SHUT_RDWR); shutdown(s, SHUT_RDWR); if (TEST_RETURN != sb.st_size) { tst_resm(TFAIL, "sendfile(2) failed to return " "expected value, expected: %"PRId64", " "got: %ld", (int64_t)sb.st_size, TEST_RETURN); kill(child_pid, SIGKILL); } else if (after_pos != sb.st_size) { tst_resm(TFAIL, "sendfile(2) failed to update " " the file position of in_fd, " "expected file position: %"PRId64", " "actual file position %"PRId64, (int64_t)sb.st_size, (int64_t)after_pos); kill(child_pid, SIGKILL); } else { tst_resm(TPASS, "functionality of sendfile() is " "correct"); wait_status = waitpid(-1, &wait_stat, 0); } } else { tst_resm(TPASS, "call succeeded"); /* Close the sockets */ shutdown(sockfd, SHUT_RDWR); shutdown(s, SHUT_RDWR); if (TEST_RETURN != sb.st_size) { kill(child_pid, SIGKILL); } else { wait_status = waitpid(-1, &wait_stat, 0); } } close(in_fd); }
int main(int argc, char *argv[]) { Server *server = create_server(); server->port = PORT; server->handler = &handler; server_start(server); return 0; }
int main() { int fd[2] = {-1, -1}; int server = -1, client = -1; FILE *fp = NULL; FILE *fp2 = NULL; fp = fopen("a.txt", "w"); if (fp == NULL) { fprintf(stderr, "fopen(a.txt) failed: %s\n", strerror(errno)); goto ERR_FOPEN; } fd[0] = fileno(fp); printf("a.txt:%d\n", fd[0]); fp2 = fopen("aa.txt", "w"); if (fp2 == NULL) { fprintf(stderr, "fopen(aa.txt) failed: %s\n", strerror(errno)); goto ERR_FOPEN; } fd[1] = fileno(fp2); printf("aa.txt:%d\n", fd[1]); server = create_server(); if (server < 0) { fprintf(stderr, "create_server failed\n"); goto ERR_CREATE_SERVER; } while(1) { client = accept(server, NULL, NULL); fprintf(stderr, "client accept %d\n", client); if (client < 0) { fprintf(stderr, "accept failed\n"); goto ERR_ACCEPT; } if (send_file_descriptor(client, fd) < 0) { fprintf(stderr, "send_file_descriptor failed: %s\n", strerror(errno)); goto ERR_SEND_FILE_DESCRIPTOR; } if (shutdown(client, SHUT_RDWR) < 0) { fprintf(stderr, "shutdown failed: %s\n", strerror(errno)); goto ERR_SHUTDOWN; } } ERR_SHUTDOWN: ERR_SEND_FILE_DESCRIPTOR: close(client); ERR_ACCEPT: close(server); ERR_CREATE_SERVER: fclose(fp); fclose(fp2); ERR_FOPEN: return 0; }
void do_sendfile(int prot, int pass_unmapped_buffer) { OFF_T *protected_buffer; int in_fd; struct stat sb; protected_buffer = mmap(NULL, sizeof(*protected_buffer), prot, MAP_SHARED | MAP_ANONYMOUS, -1, 0); if (protected_buffer == MAP_FAILED) { tst_brkm(TBROK, cleanup, "mmap failed: %d", errno); } out_fd = create_server(); if ((in_fd = open(in_file, O_RDONLY)) < 0) { tst_brkm(TBROK, cleanup, "open failed: %d", errno); } if (stat(in_file, &sb) < 0) { tst_brkm(TBROK, cleanup, "stat failed: %d", errno); } if (pass_unmapped_buffer) { if (munmap(protected_buffer, sizeof(*protected_buffer)) < 0) { tst_brkm(TBROK, cleanup, "munmap failed: %d", errno); } } TEST(sendfile(out_fd, in_fd, protected_buffer, sb.st_size)); if (TEST_RETURN != -1) { tst_resm(TFAIL, "call succeeded unexpectedly"); } else { TEST_ERROR_LOG(TEST_ERRNO); if (TEST_ERRNO != EFAULT) { tst_resm(TFAIL, "sendfile returned unexpected " "errno, expected: %d, got: %d", EFAULT, TEST_ERRNO); } else { tst_resm(TPASS, "sendfile() returned %d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } } shutdown(sockfd, SHUT_RDWR); shutdown(s, SHUT_RDWR); kill(child_pid, SIGKILL); close(in_fd); if (!pass_unmapped_buffer) { /* Not unmapped yet. So do it now. */ munmap(protected_buffer, sizeof(*protected_buffer)); } }
int main() { int i; int server_socket = create_server(); client_data * * client_list = malloc(max_users * sizeof(*client_list)); for (i = 0; i < max_users; i += 1) client_list[i] = malloc(sizeof(client_data)); for (i = 0; i < max_users; i += 1) { client_list[i]->initial_one = '0'; client_list[i]->initial_two = '0'; client_list[i]->room_socket = 0; } manage_clients(server_socket, client_list); }
int main(int ac, char **av) { t_ftp f; f.port = (ac < 2 ? PORT_DEFAULT : av[1]); if (create_server(&f) == TRUE) while ((f.cs = xaccept(f.s, NULL, NULL)) > 0) get_client(&f); close(f.s); return (TRUE); }
int main(int argc, char **argv) { int sock; if (argc != 2) shell_perror("USAGE: ./serveur [port]"); sock = create_server(ft_atoi(argv[1])); server(sock); close(sock); return (0); }
/** * Creates a new server connection. * * The method creates a server connection instance * but does not put it in listen mode. * Anyway it selects and reserves a free channel to listen for * incoming connections on after the listen method is called. * * @param auth JAVACALL_TRUE if authication is required * @param authz JAVACALL_TRUE if authorization is required * @param enc JAVACALL_TRUE if required to be encrypted * @param master JAVACALL_TRUE if required to be a connection's master * @param pHandle pointer to connection handle variable, * new connection handle returned in result. * @param cn pointer to variable, where reserved channel is returned in. * * @retval JAVACALL_OK on success, * @retval JAVACALL_FAIL otherwise */ javacall_result javacall_bt_rfcomm_create_server( javacall_bool auth, javacall_bool authz, javacall_bool enc, javacall_bool master, /*OUT*/javacall_handle* pHandle, /*OUT*/int* pCn) { return create_server(RFCOMM, -1, -1, auth, authz, enc, master, pHandle, pCn); }
c_netuser::c_netuser(const std::string &username, int port) : c_user(username), server_port(port), client_socket(m_io_service), server_socket(m_io_service), m_acceptor(m_io_service, ip::tcp::endpoint(ip::tcp::v6(),server_port)), m_stop_flag(false) { create_server(); threads_maker(2); }
void Config::reset() { /** Make sure the servers exist before checking that connectivity is OK */ for (int i = 0; i < test_->repl->N; i++) { if (created_servers_.find(i) == created_servers_.end()) { create_server(i); add_server(i); } } }
int main(int argc, char *argv[]) { SOCKET client_socket, server_socket; int read_size; server_socket = create_server(); client_socket = connect_to_client(server_socket); read_size = main_echo_cycle(client_socket); check_recv_last_response(read_size); cleanup(server_socket, client_socket); return 0; }
int main(int argc, char *argv[]) { int server_fd = create_server("127.0.0.1", atoi(argv[1])); int efd = epoll_create(128); struct epoll_event e; e.events = EPOLLIN; e.data.fd = server_fd; epoll_ctl(efd, EPOLL_CTL_ADD, server_fd, &e); struct epoll_event events[128]; for ( ;; ) { int n = epoll_wait(efd, events, 128, -1); if (n == -1) { perror("epoll_wait failed"); close(server_fd); close(efd); return 1; } for (int i = 0; i < n; ++i) { int revents = events[i].events; int fd = events[i].data.fd; if (revents & EPOLLIN) { if (fd == server_fd) { struct sockaddr_in addr; int addrlen; int cfd = accept4(server_fd, (struct sockaddr *)&addr, &addrlen, SOCK_NONBLOCK); struct epoll_event e ; e.data.fd = cfd; e.events = EPOLLIN | EPOLLET | EPOLLRDHUP; epoll_ctl(efd, EPOLL_CTL_ADD, cfd, &e); } else { if (revents & EPOLLRDHUP) { printf("client :%d closed", fd); close(fd); continue; } } } if (revents & EPOLLOUT) { } } } }
int main(int ac, char **av, char **env) { t_all *all; int port; if (ac != 2) usage(av[0]); port = ft_atoi(av[1]); all = s_init_all(env); all->sv->sock = create_server(port); loop(all); return (0); }
int main(int argc, const char *argv[]) { parse_ini("cfg.ini", ini_parser, NULL); int fd = create_server(1001, 1); if( fd == -1 ) return 0; while(1) { udp_receive(fd, packet_recvier); } return 0; }
int main(int argc, char **argv) { printf("Frozen-Bubble server version 0.001_1 (protocol version %d.%d)\n", proto_major, proto_minor); printf("\n"); printf("Copyright (c) 2004-2008 Guillaume Cottenceau.\n"); printf("This is free software; see the source for copying conditions. There is NO\n"); printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"); printf("\n"); create_server(argc, argv); connections_manager(); return 0; }
/** * Example SSL server that accepts a client and echos back anything it receives. * Test using `curl -I https://127.0.0.1:8081 --insecure` */ int main(int arc, char **argv) { int fd = create_server(); if (fd < 0) { exit(1); } int cd; while ((cd = accept(fd, 0, 0)) != -1) { ssl_run(cd); close(cd); } return 0; }
int main(void){ int server_socket = create_server(8080); if(server_socket == -1){ perror("Impossible de creer le serveur"); return -1; } while (1) { accept_client(server_socket); } return 0; }