int main(int argc, char *argv[]) { if (argc <= 1) { usage(argv[0]); } int epoll_fd = create_epoll_reactor(); assert(epoll_fd > 0); int c; while ((c = getopt(argc, argv, "chs")) != EOF) { switch (c) { case 'c': create_tcp_client(epoll_fd); break; case 's': create_tcp_server(epoll_fd); break; default: usage(argv[0]); } } pthread_t tid = pthread_create(&tid, NULL, &start_reactor, (void*)&epoll_fd); read_from_cli(); return 0; }
void eyed_loop(unsigned short port) { cio_err_t err; socket_fd_t fd; struct eyed_server server; server.cam_dev = NULL; if (cio_dispatcher_init(&server.disp) != CIO_ERR_SUCCESS) return ; if (cam_open_dev(&server.cam_dev, 0) != CAM_ERR_SUCCESS) goto on_error; fd = create_tcp_server(port); if (socket_fd_is_invalid(fd)) goto on_error; err = cio_handle_init(&server.handle, fd, NULL, on_server_accept, NULL, on_server_close, &server); if (cio_err_is_failure(err)) goto on_error; /* no longer belongs to us */ socket_fd_reset(fd); err = cio_dispatcher_add_handle(&server.disp, &server.handle); if (cio_err_is_failure(err)) goto on_error; while (!cio_dispatcher_is_done(&server.disp)) cio_dispatcher_dispatch(&server.disp, (void*)&server); on_error: if (!socket_fd_is_invalid(fd)) socket_fd_close(fd); if (server.cam_dev != NULL) cam_close_dev(server.cam_dev); cio_dispatcher_release(&server.disp); }
int main() { struct rlimit rl; rl.rlim_max = rl.rlim_cur = 1024*64; if (setrlimit(RLIMIT_NOFILE, &rl) < -1) { return -1; } fiber_mutex_init(&mtx); memset((char*)sharedArr, 0, 64); const char *server_ip = "127.0.0.1"; struct Scheduler *sch = create_scheduler(8); if (sch == NULL) return 0; struct TcpServer *server = create_tcp_server(server_ip, 12400, data_processor); if (server == NULL) return 0; start_scheduler(sch); run_tcp_server(sch, server); return 0; }
void run_server(int network_port, int verbose_flag) { verbose = verbose_flag; signal(SIGINT, &sigterm); vars = new nw_var_t[PAYLOAD_SIZE-1]; //Can't be more that this many vars sck = create_tcp_server(network_port); pthread_create(&input_thread, NULL, *input_handler, NULL); while(run) { check_new_connections(); if(run_test > -1) { test(run_test); run_test = -1; } read_all_clients(0); } stop_clients(); close_socket(sck); }
pj_status_t pjmedia_sxs_port_server_create(// pj_pool_t *pool, // const char *filename, unsigned sampling_rate, unsigned channel_count, unsigned samples_per_frame, unsigned bits_per_sample, unsigned flags, pj_ssize_t buff_size, pjmedia_port **p_port) { sxs_port *fport; pjmedia_wave_hdr wave_hdr; pj_ssize_t size; pj_str_t name; pj_status_t status; char f_type; /* Check arguments. */ // PJ_ASSERT_RETURN(pool && filename && p_port, PJ_EINVAL); /* Only supports 16bits per sample for now. * See flush_buffer(). */ PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL); fport = (sxs_port_t *)calloc(1, sizeof(sxs_port_t)); memset(fport, 0, sizeof(sxs_port_t)); fport->eph = g_param->epfd; // fport->in_vocie_frame_rb = ringbuffer_create(1024*1024*2); fport->use_frame_buff = true; // fport->use_frame_buff = false; memset(fport->lock_free_rbuf_ptr, 0, sizeof(fport->lock_free_rbuf_ptr)); fport->lock_free_rbuf_head_pos = fport->lock_free_rbuf_tail_pos = 0; name = pj_str("hahahahahaha"); pjmedia_port_info_init(&fport->base.info, &name, SIGNATURE, sampling_rate, channel_count, bits_per_sample, samples_per_frame); // fport->base.get_frame = &file_get_frame; // fport->base.put_frame = &file_put_frame; fport->base.get_frame = NULL; fport->base.put_frame = NULL; // fport->base.on_destroy = &file_on_destroy; if (flags == PJMEDIA_FILE_WRITE_ALAW) { fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_ALAW; fport->bytes_per_sample = 1; } else if (flags == PJMEDIA_FILE_WRITE_ULAW) { fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_ULAW; fport->bytes_per_sample = 1; } else { fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_PCM; fport->bytes_per_sample = 2; } /* Set buffer size. */ if (buff_size < 1) buff_size = PJMEDIA_FILE_PORT_BUFSIZE; fport->bufsize = buff_size; /* Check that buffer size is greater than bytes per frame */ // pj_assert(fport->bufsize >= fport->base.info.bytes_per_frame); // socket, bind, listen, accept g_param->mpo_serv_sock = fport->out_serv_fd = create_tcp_server(); g_param->mpi_serv_sock = fport->in_serv_fd = create_tcp_server(); /* Done. */ *p_port = &fport->base; PJ_LOG(4,(THIS_FILE, "File writer '%.*s' created: samp.rate=%d, bufsize=%uKB, bytes per frame=%d", (int)fport->base.info.name.slen, fport->base.info.name.ptr, fport->base.info.clock_rate, fport->bufsize / 1000, fport->base.info.bytes_per_frame)); return PJ_SUCCESS; return 0; }
int hub(const char * service) { int sockserver; struct sockaddr_in address; socklen_t length = sizeof(struct sockaddr_in); if ((sockserver = create_tcp_server(NULL, service)) < 0) { return -1; } if (nonblock(sockserver) < 0) { return -1; } char buffer[BUF_SIZE]; int sockclient[MAX_CONNECTION]; int sockclientc = 0; int i, j, r, sock, run, dataread; fd_set listenfdset; run = 1; while (run) { FD_ZERO(&listenfdset); FD_SET(sockserver, &listenfdset); for (i = 0 ; i < sockclientc ; i++) { FD_SET(sockclient[i], &listenfdset); } if (select(FD_SETSIZE, &listenfdset, NULL, NULL, NULL) < 0) { if (errno != EINTR) { perror("select"); return -1; } else { continue; } } if (FD_ISSET(sockserver, &listenfdset)) { if ((sock = accept(sockserver, (struct sockaddr*)(&address), &length)) < 0) { perror("accept"); return -1; } if (nonblock(sock) < 0) { return -1; } if (sockclientc == MAX_CONNECTION) { char * toomanyco = "Sorry, no slot available, retry later\n"; if (write(sock, toomanyco, strlen(toomanyco)) < -1) { perror("write"); } close(sock); } else { sockclient[sockclientc++] = sock; fprintf(stdout, "%i connections [+1]\n", sockclientc); fflush(stdout); } } for (i = 0 ; i < sockclientc ; i++) { if (FD_ISSET(sockclient[i], &listenfdset)) { r = read(sockclient[i], buffer, BUF_SIZE); if (r <= 0) { close(sockclient[i]); sockclient[i] = sockclient[--sockclientc]; fprintf(stdout, "%i connections [-1]\n", sockclientc); fflush(stdout); if (r < 0 && errno != ECONNRESET) { perror("read"); //return -1; } } else { if (dispatches(sockclientc, sockclient, i, r, buffer) < 0) { return -1; } } } } } }
int main(int argc, char const *argv[]) { int tcp_server_fd; int tcp_client_fd; int unix_server_fd; int temp_client_fd; int rv; int test_fd; fd_set readfds; fd_set testfds; if ((rv = init()) < 0) { perror("failed to init send message"); exit(EXIT_FAILURE); } tcp_server_fd = create_tcp_server(local_tcp_server_ip, local_tcp_server_port); if (tcp_server_fd < 0) { perror("Failed to create tcp server"); exit(EXIT_FAILURE); } tcp_client_fd = create_tcp_client(); if (tcp_client_fd < 0) { perror("Failed to create tcp client"); exit(EXIT_FAILURE); } unix_server_fd = create_unix_server(unix_server_path); if (unix_server_fd < 0) { perror("Failed to create unix server"); exit(EXIT_FAILURE); } FD_ZERO(&readfds); FD_SET(tcp_server_fd, &readfds); FD_SET(unix_server_fd, &readfds); while (1) { testfds = readfds; rv = select(FD_SETSIZE, &testfds, (fd_set *)NULL, (fd_set *)NULL, (struct timeval *)NULL); switch (rv) { case -1: perror("select"); break; default: for (test_fd = 0; test_fd < FD_SETSIZE; test_fd++) { if (FD_ISSET(test_fd, &testfds)) { if (test_fd == tcp_server_fd) { temp_client_fd = accept_tcp_client(tcp_server_fd); if (temp_client_fd < 0) { continue; } printf("a client connected\n"); FD_SET(temp_client_fd, &readfds); } else if (test_fd == unix_server_fd) { rv = forward_server_command(unix_server_fd, tcp_client_fd); } else { rv = receive_iridium_msgs(test_fd); if (rv <= 0) { printf("a client disconnect\n"); FD_CLR(test_fd, &readfds); close(test_fd); } } } } } } close(tcp_server_fd); close(unix_server_fd); close(tcp_client_fd); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { const char *addr = "0.0.0.0"; ushort port = 6889; int sfd = -1; int cfd = -1; struct sockaddr_in sa; socklen_t salen = sizeof(sa); int opmode = OPMODE_ECHO; if (argc > 1) { if (strcmp(argv[1], "-") == 0) opmode = OPMODE_WRITE_STDOUT; else if (strcasecmp(argv[1], "discard") == 0) opmode = OPMODE_DISCARD; else if (strcasecmp(argv[1], "echo") == 0) opmode = OPMODE_ECHO; else D_DEBUG("Unknown opmode `%s', assume `echo'.\n", argv[1]); } D_DEBUG("opmode = %d", opmode); D_DEBUG("srvmode = %d", g_srvmode); signal(SIGCHLD, sighdl); sfd = create_tcp_server(addr, port); if (sfd == -1) exit(1); for (;;) { cfd = accept(sfd, (struct sockaddr *)&sa, &salen); if (cfd == -1) { if (errno == EINTR) continue; perror("accept"); exit(1); } D_DEBUG("client [%08x:%d] connected.\n", sa.sin_addr.s_addr, ntohs(sa.sin_port)); if (g_srvmode == SRVMODE_SINGLE) { handle_client(cfd, opmode); } else if (g_srvmode == SRVMODE_MP) { int subpid = fork(); if (subpid == -1) { // error occured perror("fork"); } else if (subpid == 0) { // child close(sfd), sfd = -1; handle_client(cfd, opmode); close(cfd), cfd = -1; exit(0); } else { // parent // do nothing } } close(cfd), cfd = -1; } exit(0); }
int main(int argc, char *argv[]) { int sock, ret, server_fd, pid, status; struct sockaddr_in addr_in; socklen_t addrlen = sizeof(addr_in); int c, level = LOG_DEBUG, sysl = 0; int option_index = 0; char *short_options = "sh"; struct option long_options[] = { {"syslog", no_argument, 0, 's'}, {"level", required_argument, 0, 'l'}, {"help", required_argument, 0, 'h'} }; while ((c = getopt_long_only(argc, argv, short_options, long_options, &option_index)) != -1) switch (c) { case 's': sysl = 1; break; case 'l': level = atoi(optarg); break; case 'h': printf("Usage %s [OPTIONS]\n", argv[0]); printf("\nCommand line options\n\n"); printf("\t\t-l <level>\t log level\n"); printf("\t\t-s\t use of syslog\n"); return 0; } logger_init(sysl, level); server_fd = create_tcp_server(SERVER_PORT); if (server_fd < 0) { ERROR("cannot create server socket"); return 0; } while (1) { sock = accept(server_fd, (struct sockaddr *)&addr_in, &addrlen); if (sock < 0) { if (errno == EAGAIN || errno == EWOULDBLOCK) goto waitpid; ERROR("socket accept error %s", strerror(errno)); return -1; } ret = fork(); if (ret < 0) { ERROR("fork error %s", strerror(errno)); break; } if (ret == 0) { char buffer[50]; DEBUG("New process on socket %d", sock); snprintf(buffer, sizeof(buffer), resp_xml, status_str[0]); ret = send_resp(sock, buffer, strlen(buffer)); if (ret < 0) ERROR("send_resp error %d", ret); handle_request(sock); DEBUG("close sock %d", sock); close(sock); exit(0); } close(sock); waitpid: do { pid = waitpid(0, &status, WNOHANG); if (pid < 0) { if (errno != ECHILD) ERROR("waitpid error %s", strerror(errno)); break; } else if (pid) { char str[100]; printWaitStatus(str, status); INFO("waitpid() PID=%ld status=0x%04x: %s", (long) pid, (unsigned int) status, str); } } while (pid); sleep(1); } return 0; }
void echoserver::start() { listenfd_ = create_tcp_server(host_.c_str(), port_); schedule::ref().new_coroutine(echo_accept_handler, this); }