Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
Arquivo: eyed.c Projeto: texane/eyed
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);
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
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);
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
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;
					}
				}
			}
		}
	}
}
Exemplo n.º 7
0
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);
}
Exemplo n.º 8
0
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);
}
Exemplo n.º 9
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;
}
Exemplo n.º 10
0
void echoserver::start()
{
	listenfd_ = create_tcp_server(host_.c_str(), port_);

	schedule::ref().new_coroutine(echo_accept_handler, this);
}