示例#1
0
int
main(int argc, char *argv[])
{
    char c;
    int i=0;
 
    nonblock(NB_ENABLE);
    while(!i) {
        usleep(1);
        i=kbhit();
        if (i!=0) {
            c=fgetc(stdin);
            if (c=='q') {
                i=1;
            } else {
                i=0;
            }
        }

        fprintf(stderr,"%d ",i);
    }
    printf("\n you hit %c. \n",c);
    nonblock(NB_DISABLE);
 
    return 0;
} /* main */
示例#2
0
static void
tls_exec_server(const char *user, int startfd, const char *privkey,
    const char *cert, int debuglevel)
{
	SSL_CTX *sslctx;
	SSL *ssl;
	int sockfd, tcpfd, ret;

	pjdlog_debug_set(debuglevel);
	pjdlog_prefix_set("[TLS sandbox] (server) ");
#ifdef HAVE_SETPROCTITLE
	setproctitle("[TLS sandbox] (server) ");
#endif

	sockfd = startfd;
	tcpfd = startfd + 1;

	SSL_load_error_strings();
	SSL_library_init();

	sslctx = SSL_CTX_new(TLSv1_server_method());
	if (sslctx == NULL)
		pjdlog_exitx(EX_TEMPFAIL, "SSL_CTX_new() failed.");

	SSL_CTX_set_options(sslctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);

	ssl = SSL_new(sslctx);
	if (ssl == NULL)
		pjdlog_exitx(EX_TEMPFAIL, "SSL_new() failed.");

	if (SSL_use_RSAPrivateKey_file(ssl, privkey, SSL_FILETYPE_PEM) != 1) {
		ssl_log_errors();
		pjdlog_exitx(EX_CONFIG,
		    "SSL_use_RSAPrivateKey_file(%s) failed.", privkey);
	}

	if (SSL_use_certificate_file(ssl, cert, SSL_FILETYPE_PEM) != 1) {
		ssl_log_errors();
		pjdlog_exitx(EX_CONFIG, "SSL_use_certificate_file(%s) failed.",
		    cert);
	}

	if (sandbox(user, true, "proto_tls server") != 0)
		pjdlog_exitx(EX_CONFIG, "Unable to sandbox TLS server.");
	pjdlog_debug(1, "Privileges successfully dropped.");

	nonblock(sockfd);
	nonblock(tcpfd);

	if (SSL_set_fd(ssl, tcpfd) != 1)
		pjdlog_exitx(EX_TEMPFAIL, "SSL_set_fd() failed.");

	ret = SSL_accept(ssl);
	ssl_check_error(ssl, ret);

	tls_loop(sockfd, ssl);
}
示例#3
0
bool Socket::listen()
{
	int _backLog = 128;
	if (!_isServer){
		return false;
	}
	if (!checkSock()) {
        return false;
    }
	int value = 1;

	nonblock(_fd);
	
	setsockopt(_fd, SOL_SOCKET, SO_REUSEADDR,
                         (const void *)(&value), sizeof(value));
	
	if (::bind(_fd, (struct sockaddr *)&_address,
               sizeof(_address)) < 0) {
        return false;
    }

    if (::listen(_fd, _backLog) < 0) {
        return false;
    }

    return true;
	
}
示例#4
0
int new_connection(int s)
{
	struct sockaddr_in isa;
	/* struct sockaddr peer; */
	int i;
	int t;
	char buf[100];

	i = sizeof(isa);
	getsockname(s, &isa, &i);


	if ((t = accept(s, &isa, &i)) < 0)
	{
		perror("Accept");
		return(-1);
	}
	nonblock(t);

	/*

	i = sizeof(peer);
	if (!getpeername(t, &peer, &i))
	{
		*(peer.sa_data + 49) = '\0';
		sprintf(buf, "New connection from addr %s\n", peer.sa_data);
		log(buf);
	}

	*/

	return(t);
}
示例#5
0
文件: zb.c 项目: kheradmand/Break
void start_connect(struct connection *c)
{
  c->read = 0;
  c->bread = 0;
  c->keepalive = 0;
  c->cbx = 0; 
  c->gotheader = 0;

  c->fd = socket(AF_INET, SOCK_STREAM, 0);
  if(c->fd<0) err("socket");

  nonblock(c->fd);
  gettimeofday(&c->start,0);

  if(connect(c->fd, (struct sockaddr *) &server, sizeof(server))<0) {
    if(errno==EINPROGRESS) {
      c->state = STATE_CONNECTING;
      FD_SET(c->fd, &writebits);
      return;
    }
    else {
      close(c->fd);
      err_conn++;
      if(bad++>10) {
	printf("\nTest aborted after 10 failures\n\n");
	exit(1);
      } 
      start_connect(c);
    }      
  }
  
  /* connected first time */
  write_request(c);
}
示例#6
0
文件: util.c 项目: kdhp/play
int
getcmd(struct cmd *cmd) {
	size_t j;
	int c;
	assert(cmd != NULL && cmd->i >= 0 && cmd->i <= CMDMAX);
	if (cmd->f == NULL)
		return CDONE; 
	if (cmd->conn == 0)
		nonblock(fileno(cmd->f));
loop:
	do {
		while ((c = fgetc(cmd->f)) != EOF && !isspace(c))
			if (cmd->i < CMDMAX)
				cmd->buffer[cmd->i++] = toupper(c);
		if (c == EOF) {
			if (ferror(cmd->f) && errno == EIO) {
				cmd->conn = 1;
				cmd->i = 0;
			}
			clearerr(cmd->f);
			return CDONE;
		}
	} while (cmd->i == 0);
	cmd->conn = 1;
	if (cmd->i >= CMDMAX) {
		cmd->i = 0;
		return CINVALID;
	}
	cmd->buffer[cmd->i] = '\0';
	for (j = 0; ctable[j].type != CINVALID; j++)
		if (strcmp(ctable[j].command, cmd->buffer) == 0)
			break;
	cmd->i = 0;
	return ctable[j].type;
}
示例#7
0
static void
report_accept(struct silly_socket *ss, struct socket *listen)
{
        const char *str;
        struct socket *s;
        struct sockaddr_in addr;
        struct silly_message_socket *sa;
        char buff[INET_ADDRSTRLEN];
        assert(ADDRLEN >= INET_ADDRSTRLEN + 8);
        socklen_t len = sizeof(struct sockaddr);
        int fd = accept(listen->fd, (struct sockaddr *)&addr, &len);
        if (fd < 0)
                return ;
        sa = silly_malloc(sizeof(*sa) + ADDRLEN);
        sa->data = (uint8_t *)(sa + 1);
        sa->type = SILLY_SACCEPT;
        str = inet_ntop(addr.sin_family, &addr.sin_addr, buff, sizeof(buff));
        snprintf((char *)sa->data, ADDRLEN, "%s:%d", str, ntohs(addr.sin_port));
        nonblock(fd);
        keepalive(fd);
        nodelay(fd);
        s = newsocket(ss, NULL, fd, STYPE_SOCKET, NULL);
        if (s == NULL)
                return;
        sa->sid = s->sid;
        sa->ud = listen->sid;
        silly_worker_push(tocommon(sa));         
        return ;
}
示例#8
0
int
silly_socket_udpbind(const char *ip, uint16_t port)
{
        int fd;
        int err;
        struct socket *s;
        struct cmdpacket cmd;
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0)
                return -1;
        err = bindfd(fd, ip, port);
        if (err < 0)
                goto end;
        nonblock(fd);
        s = allocsocket(SSOCKET, STYPE_ALLOCED, PROTOCOL_UDP);
        if (s == NULL) {
                fprintf(stderr, "[socket] udplisten %s:%d allocsocket fail\n", ip, port);
                goto end;
        }
        s->fd = fd;
        cmd.type = 'B';
        cmd.u.listen.sid = s->sid;
        pipe_blockwrite(SSOCKET->ctrlsendfd, &cmd);
        return s->sid;
end:
        perror("udplisten");
        close(fd);
        return -1;
}
示例#9
0
int try_output(int is_stderr)
{
    bufchain *chain = (is_stderr ? &stderr_data : &stdout_data);
    int fd = (is_stderr ? STDERR_FILENO : STDOUT_FILENO);
    void *senddata;
    int sendlen, ret;

    if (bufchain_size(chain) > 0) {
        int prev_nonblock = nonblock(fd);
        do {
            bufchain_prefix(chain, &senddata, &sendlen);
            ret = write(fd, senddata, sendlen);
            if (ret > 0)
                bufchain_consume(chain, ret);
        } while (ret == sendlen && bufchain_size(chain) != 0);
        if (!prev_nonblock)
            no_nonblock(fd);
        if (ret < 0 && errno != EAGAIN) {
            perror(is_stderr ? "stderr: write" : "stdout: write");
            exit(1);
        }
    }
    if (outgoingeof == EOF_PENDING && bufchain_size(&stdout_data) == 0) {
        close(STDOUT_FILENO);
        outgoingeof = EOF_SENT;
    }
    return bufchain_size(&stdout_data) + bufchain_size(&stderr_data);
}
示例#10
0
int main(void)
{
  struct io_pollfd ifd;
  struct io_pollfd *rfds;
  unsigned long len;
  char buf[4];

  check_core();

  init_core(&iop);
  test_assert(io_poll_size(&iop) == 0);
  verify(&iop);

  test_assert(pipe(pfd) != -1);
  test_assert(nonblock(pfd[1]) != -1);
  test_assert(nonblock(pfd[0]) != -1);

  /* test for readability */
  ifd.events = IO_POLL_READ;
  ifd.fd = pfd[0];
  test_assert(io_poll_add(&iop, &ifd) == 1);
  
  /* pipe gets readability */
  test_assert(write(pfd[1], "AAAA", 4) == 4);

  test_assert(io_poll_wait(&iop, 0) == 1);
  io_poll_rfds(&iop, &rfds, &len);
  test_assert(len == 1);
  test_assert(rfds[0].fd == ifd.fd);
  test_assert(io_poll_got_read(&rfds[0]) == 1);
  test_assert(read(rfds[0].fd, buf, 4) == 4);
  test_assert(bin_same(buf, "AAAA", 4) == 1);

  /* send EOF */
  test_assert(close(pfd[1]) != -1);

  test_assert(io_poll_wait(&iop, 0) == 1);
  io_poll_rfds(&iop, &rfds, &len);
  test_assert(len == 1);
  test_assert(rfds[0].fd == ifd.fd);
  test_assert(read(rfds[0].fd, buf, 4) == 0 || io_poll_got_eof(&rfds[0]) == 1);
 
  test_assert(io_poll_rm(&iop, &ifd) == 1);
  test_assert(close(pfd[0]) != -1);
  test_assert(io_poll_free(&iop));
  return 0;
}
示例#11
0
HybridConnection*
hybrid_proxy_connect(const gchar *hostname, gint port, connect_callback func,
                     gpointer user_data)
{
    gint              sk;
    struct sockaddr   addr;
    HybridConnection *conn;

    g_return_val_if_fail(port != 0, NULL);
    g_return_val_if_fail(hostname != NULL, NULL);

    hybrid_debug_info("connect", "connecting to %s:%d", hostname, port);

    conn = g_new0(HybridConnection, 1);

    if ((sk = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

        hybrid_debug_error("connect", "create socket: %s", strerror(errno));
        hybrid_connection_destroy(conn);

        return NULL;
    }

    if (nonblock(sk) != HYBRID_OK) {

        hybrid_connection_destroy(conn);
        return NULL;
    }

    if (addr_init(hostname, port, &addr) != HYBRID_OK) {

        hybrid_connection_destroy(conn);
        return NULL;
    }

    if (connect(sk, &addr, sizeof(addr)) != 0) {

        if (errno != EINPROGRESS) {

            hybrid_debug_error("connect", "connect to \'%s:%d\':%s", hostname,
                               port, strerror(errno));
            hybrid_connection_destroy(conn);
            return NULL;
        }

        hybrid_debug_info("connect", "connect in progress");

        hybrid_event_add(sk, HYBRID_EVENT_WRITE, func, user_data);
    } else {
        /* connection establish imediately */
        func(sk, user_data);
    }

    conn->sk   = sk;
    conn->host = g_strdup(hostname);
    conn->port = port;

    return conn;
}
示例#12
0
/*
 * Open a UDP connection.
 */
int
udp_open(u_int32_t dst, int sport, int rport, int nonblocking)
{
	int fd;
	int len;
	int bufsize;
	struct sockaddr_in sin;

	fd = socket(AF_INET, SOCK_DGRAM, 0);
	if (fd < 0) {
		perror("socket");
		exit(1);
	}
	if (nonblocking)
		nonblock(fd);

	/*
	 * bind the local host's address to this socket.  If that
	 * fails, another process probably has the addresses bound so
	 * just exit.
	 */
	memset((char *)&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(rport);
	if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
		perror("bind");
		return (-1);
	}

	memset((char *)&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(sport);
	sin.sin_addr.s_addr = dst;
	if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
		perror("connect");
		return(-1);
	}
	/*
	 * (try to) make the transmit socket buffer size large.
	 */
	bufsize = 80 * 1024;
	if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize,
		       sizeof(bufsize)) < 0) {
		bufsize = 48 * 1024;
		if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize,
			       sizeof(bufsize)) < 0)
			perror("SO_SNDBUF");
	}

	bufsize = 80 * 1024;
	if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize,
			sizeof(bufsize)) < 0) {
		bufsize = 32 * 1024;
		if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize,
				sizeof(bufsize)) < 0)
			perror("SO_RCVBUF");
	}
	return (fd);
}
示例#13
0
void monitor() {
	sfd = tcpSocket();
	if (!sfd) die(1,"Could not allocate socket");
	if (reuseSocket(sfd)) die(2,"Failed to reuse socket %d",sfd);
	if (bindSocket(sfd, address, htons(port))) die(3,"Failed to bind to %d.%d.%d.%d:%d",IP(address),port);
	if (listen(sfd,backlog)) die(4,"Failed to listen on port %d",port);
	if (nonblock(sfd)<0) die(5,"Failed to set nonblocking on socket %d", sfd);
	debug("Listening on %d.%d.%d.%d:%d",IP(address),port);
}
示例#14
0
void die()
{
	fprintf(stderr, "\nCTRL+C pressed, terminating app\n");

	if (!g_nosigint)
		easynmc_stop_app(g_handle);

	if (isatty(STDIN_FILENO))
		nonblock(STDIN_FILENO,  0);
	exit(0);	
}
示例#15
0
文件: net-rtip.cpp 项目: pierz/vic
int rtipChannel::open(u_int32_t addr, int port,
		      rcapTraffic* traffic, rcapRequirements* requirements)
{
	u_int32_t local = findifaddr(addr, port);

	if (local < addr) {
		rsock_ = openrsock(addr, port, rlcid_);
		ssock_ = openssock(addr, port, traffic, requirements, slcid_);
	} else {
		ssock_ = openssock(addr, port, traffic, requirements, slcid_);
		rsock_ = openrsock(addr, port, rlcid_);
	}
	if (ssock_ >= 0)
		nonblock(ssock_);
	if (rsock_ >= 0)
		nonblock(rsock_);
		
	/*XXX*/
	dst_ = addr;
}
示例#16
0
bool Server::run()
{

int choosen;

	  while(1)
	  { 
	    /* wait for a connection */
	    addrlen = sizeof(peer_name);
	    newsockfd = accept(sockd, (struct sockaddr*)&peer_name,(socklen_t*) &addrlen);
		
		
        if (newsockfd < 0)
	    perror("ERROR on accept");
	    else{
		
			nonblock(newsockfd); 
	    	
			start:
            pthread_mutex_lock(&new_connection_mutex);
			choosen=choose_thread();


	    	if( choosen == -1)
				{
					pthread_mutex_unlock(&new_connection_mutex);
					sleep(1);
					goto start;
				}
						

			if(configuration->getConfigValue(OPT_DEBUG))
            fprintf(stdout," new conn - thread choosen: %d -  nr. of connections already in queue: %d\n",choosen,threads[choosen].client_count);
			fflush(stdout);
			
			for(int i = 0; i < MAX_CLIENT_PER_THREAD; i++)
			{
				if(threads[choosen].clients[i] == 0)
				{
					threads[choosen].clients[i] = newsockfd;
					threads[choosen].client_count++;
					break;
				}
			}
	     pthread_mutex_unlock(&new_connection_mutex);
			}
			
	    
	  }

return 0;

}
示例#17
0
static void cleanup(int signal __attribute__((unused))) {
	if (sl) {
		/* Switch back to mass storage mode before closing. */
		stlink_run(sl);
		stlink_exit_debug_mode(sl);
		stlink_close(sl);
	}

	printf("\n");
	nonblock(0);
	exit(1);
}
示例#18
0
int acceptSocket(int fd) {
        struct sockaddr_in saddr;
        socklen_t len = sizeof(struct sockaddr_in);
        int sock = accept(fd,(struct sockaddr*)&saddr,&len);
	if (sock < 0) return 0;
	peer = saddr.sin_addr.s_addr;
        peer_port = saddr.sin_port;
	debug("Accepting connection from %d.%d.%d.%d:%d",IP(peer),peer_port);
	nonblock(sock);
	timeoutSocket(sock,linger);
	return sock;
}
示例#19
0
文件: fd.cpp 项目: zigzed/common
 filer::filer(coroutine *c, const char *name)
     : fd_(-1), cr_(c)
 {
     fd_ = open(name, O_LARGEFILE | O_NOATIME);
     if(fd_ == -1) {
         int r = cxx::sys::err::get();
         std::stringstream msg;
         msg << "open file \'" << name << "\' failed: ";
         throw file_error(r, msg.str());
     }
     nonblock(fd_);
 }
示例#20
0
static void control_incoming(int fd, void *p, uintptr_t u) {
	int nfd;
	struct control_tcp *c = p;
	struct control_stream *s;
	struct poller_item i;
	struct sockaddr_in sin;
	socklen_t sinl;

next:
	sinl = sizeof(sin);
	nfd = accept(fd, (struct sockaddr *) &sin, &sinl);
	if (nfd == -1) {
		if (errno == EAGAIN || errno == EWOULDBLOCK)
			return;
		goto next;
	}
	nonblock(nfd);

	ilog(LOG_INFO, "New control connection from " DF, DP(sin));

	s = obj_alloc0("control_stream", sizeof(*s), control_stream_free);

	s->fd = nfd;
	s->control = c;
	s->poller = c->poller;
	s->inbuf = streambuf_new(c->poller, nfd);
	s->outbuf = streambuf_new(c->poller, nfd);
	memcpy(&s->inaddr, &sin, sizeof(s->inaddr));
	mutex_init(&s->lock);
	s->linked = 1;

	ZERO(i);
	i.fd = nfd;
	i.closed = control_stream_closed;
	i.readable = control_stream_readable;
	i.writeable = control_stream_writeable;
	i.timer = control_stream_timer;
	i.obj = &s->obj;

	if (poller_add_item(c->poller, &i))
		goto fail;

	mutex_lock(&c->lock);
	/* let the list steal our own ref */
	c->streams = g_list_prepend(c->streams, s);
	mutex_unlock(&c->lock);

	goto next;

fail:
	obj_put(s);
	goto next;
}
示例#21
0
static void
tryconnect(struct silly_socket *ss, struct cmdpacket *cmd)
{
        int err;
        int fd;
        struct sockaddr addr;
        int sid = cmd->u.connect.sid;
        int port = cmd->u.connect.port;
        int bport = cmd->u.connect.bport;
        const char *ip = cmd->u.connect.ip;
        const char *bip = cmd->u.connect.bip;
        struct socket *s =  &ss->socketpool[HASH(sid)];
        assert(s->sid == sid);
        assert(s->type == STYPE_ALLOCED);
        tosockaddr(&addr, ip, port);
        fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd >= 0)
                err = bindfd(fd, bip, bport);
        if (fd < 0 || err < 0) {
                const char *fmt = "[socket] bind %s:%d, errno:%d\n";
                fprintf(stderr, fmt, bip, bport, errno);
                if (fd >= 0)
                        close(fd);
                report_close(ss, s, errno);
                freesocket(ss, s);
                return ;
        }
        nonblock(fd);
        keepalive(fd);
        nodelay(fd);
        err = connect(fd, &addr, sizeof(addr));
        if (err == -1 && errno != EINPROGRESS) {        //error
                const char *fmt = "[socket] tryconnect %s:%d,errno:%d\n";
                fprintf(stderr, fmt, ip, port, errno);
                close(fd);
                report_close(ss, s, errno);
                freesocket(ss, s);
                return ;
        } else if (err == 0) {  //connect
                s = newsocket(ss, s, fd, STYPE_SOCKET, report_close);
                if (s != NULL)
                        report_connected(ss, s);
                return ;
        } else {        //block
                s = newsocket(ss, s, fd, STYPE_CONNECTING, report_close);
                if (s != NULL)
                        sp_write_enable(ss->spfd, s->fd, s, 1);
        }
        return ;
}
示例#22
0
int udp_listener_init(struct udp_listener *u, struct poller *p, struct in6_addr ip, u_int16_t port, udp_listener_callback_t func, struct obj *obj) {
	struct sockaddr_in6 sin;
	struct poller_item i;
	struct udp_listener_callback *cb;

	cb = obj_alloc("udp_listener_callback", sizeof(*cb), NULL);
	cb->func = func;
	cb->p = obj_get_o(obj);

	u->fd = socket(AF_INET6, SOCK_DGRAM, 0);
	if (u->fd == -1)
		goto fail;

	nonblock(u->fd);
	reuseaddr(u->fd);
	ipv6only(u->fd, 0);

	ZERO(sin);
	sin.sin6_family = AF_INET6;
	sin.sin6_addr = ip;
	sin.sin6_port = htons(port);
	if (bind(u->fd, (struct sockaddr *) &sin, sizeof(sin)))
		goto fail;

	ZERO(i);
	i.fd = u->fd;
	i.closed = udp_listener_closed;
	i.readable = udp_listener_incoming;
	i.obj = &cb->obj;
	if (poller_add_item(p, &i))
		goto fail;

	return 0;

fail:
	if (u->fd != -1)
		close(u->fd);
	obj_put_o(obj);
	obj_put(cb);
	return -1;
}
示例#23
0
int main(int arg,char * argc[])
{

	pthread_t thread[10];
	char buf[100];
	int sfd[10];
	int n=0,a;
	while(1)
	{
		printf("ENTER THE PORNTO");
		scanf("%d",&a);
		strcpy(buf,"");
		sprintf(buf,"%d",a);
		sfd[n]=mkserver(atoi(argc[1]),0,sname);
		write(sfd[n],buf,strlen(buf));
		printf("%d\n",sfd[n]);
		nonblock(sfd[n]);
		pthread_create(&thread[n],NULL,READ,(void *)&sfd[n]);
		n++;
	}
}
示例#24
0
void cli_con()
{	
	struct sockaddr_in srv;
	struct hostent *h_name;
	int clifd;
	int n;

	bzero(&srv, sizeof(srv));
	srv.sin_family = AF_INET;
	srv.sin_port = htons(PORT);
	inet_pton(AF_INET, IP, &srv.sin_addr);	
	
	if( (clifd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		printf("ERROR clifd\n");
		exit(1);
	}

	if(connect(clifd, (struct sockaddr *) &srv, sizeof(srv)) < 0)
	{
		printf("ERROR connect\n");
		exit(1);
	}

	nonblock(clifd);
	for(n = 0; (n < MAX_CLIENT) && (clifd != -1); n++)
	{
		if(list[n] == 0) {
#ifdef DEBUG
			printf("connected %d\n", clifd);
#endif
			list[n] = clifd;
			clifd = -1;
		}
	}
	
	if(clifd != -1) {
		printf("list FULL");
	}
}
int main()
{
	int count = QSIZE/2;
	int probadd = 50;
	int probdel = 50;
	nonblock(NB_ENABLE);
	printf("Producer-Consumer simulation \n");
	printf("   The bar graph shows how full the queue is \n");
	printf("   use keys a,z, to adjust producer rate\n");
	printf("   use keys s,x, to adjust consumer rate\n");
	printf("   use q to exit\n");
	printf("----------------------------------\n");

	while(1)
	{
		int blocked = 0;
		int rp = random(probadd);	//- producer priority 
		int rc = random(probdel); 	//- consumer priority
		if (kbhit())
		{
			char c = fgetc(stdin);
			printf("\b");		//- delete it
			fflush(0);

			if (c == 'a') probadd++;
			if (c == 'z') probadd--;
			if (c == 's') probdel++;
			if (c == 'x') probdel--;
			if (c == 'q') break;
			probadd = limit(probadd, 40, 60);
			probdel = limit(probdel, 40, 60);
		}
		if (rp) blocked |= QueueAdd(rp, QSIZE);
		if (rc) blocked |= QueueDel(rc, QSIZE);
		BarDisplayEx(QueueDepth(), QSIZE, 
				&probadd, &probdel, blocked);
		usleep(20000);
	}
	QueuePrint();
}
示例#26
0
int main() {
  printf("[altair8800]\n");

  i8080_init();

  // load_mem_file("data/4kbas32.bin", 0);
  // i8080_jump(0);

  load_mem_file("data/88dskrom.bin", 0xff00);
  disk_drive.disk1.fp = fopen("data/cpm63k.dsk", "r+b");
  disk_drive.disk2.fp = fopen("data/zork.dsk", "r+b");
  disk_drive.nodisk.status = 0xff;
  i8080_jump(0xff00);

  nonblock(NB_ENABLE); //keyboard

  while (1) {
    i8080_instruction();
    //printf("%04x\n",i8080_pc());
    //usleep(1000);
  }
}
示例#27
0
int client_connect(const char *host, const char *port) {
    int rc = 0;
    struct addrinfo *addr = NULL;

    rc = getaddrinfo(host, port, NULL, &addr);
    check(rc == 0, "Failed to lookup %s:%s", host, port);

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    check(rc == 0, "Connect failed");

    rc = connect(sock, addr->ai_addr, addr->ai_addrlen);
    check(rc == 0, "Connect failed.");

    rc = nonblock(sock);
    check(rc == 0, "Can't set nonblock.");

    freeaddrinfo(addr);
    return sock;

error:
    freeaddrinfo(addr);
    return -1;
}
示例#28
0
static int
dolisten(const char *ip, uint16_t port, int backlog)
{
        int err;
        int fd;
        int reuse = 1;
        fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0)
                return -1;
        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
        err = bindfd(fd, ip, port);
        if (err < 0)
                goto end;
        nonblock(fd);
        err = listen(fd, backlog);
        if (err < 0)
                goto end;
        return fd;
end:
        perror("dolisten");
        close(fd);
        return -1;

}
示例#29
0
int main(int argc, char **argv)
{
	int core = 0; // EASYNMC_CORE_ANY; /* Default - use first available core */
	int ret; 
	char* self = "nmrun";

	if (argc < 2)
		usage(argv[0]),	exit(1);
	
	while (1)
	{		
		int c; 
		int option_index = 0;
		c = getopt_long (argc, argv, "c:h",
				 long_options, &option_index);
		
		/* Detect the end of the options. */
		if (c == -1)
			break;
     
		switch (c)
		{
		case 'c':
			if (strcmp(optarg, "all") == 0)
				core = -1;
			else
				core = atoi(optarg);
			break;
		case 'h':
			usage(argv[0]);
			exit(1);
			break;
		case '?':
		default:
			break;
		}        
	}

	char* absfile = argv[optind++];	
	int num_args = argc - optind;
	char **args = &argv[optind];

	uint32_t flags = ABSLOAD_FLAG_DEFAULT;
	
	if (g_nostdio)
		flags &= ~(ABSLOAD_FLAG_STDIO);

	struct easynmc_handle *h = easynmc_open(core); 
	g_handle = h;

	if (!h) {
		fprintf(stderr, "Failed to open core %d\n", core);
		exit(1);
	}
	
	int state; 
	if ((state = easynmc_core_state(h)) != EASYNMC_CORE_IDLE) { 
		fprintf(stderr, "Core is %s, expecting core to be idle\n", easynmc_state_name(state));
		exit(1);
	}
	
	ret = easynmc_load_abs(h, absfile, &entrypoint, flags);
	if (0!=ret) {
		fprintf(stderr, "Failed to upload abs file\n");
		exit(1);
	}

	ret = easynmc_set_args(h, self, num_args, args);
	if (ret != 0) { 
		fprintf(stderr, "WARN: Failed to set arguments. Not supported by app?\n");		
	}
	
	ret = easynmc_pollmark(h);
	
	if (ret != 0) { 
		fprintf(stderr, "Failed to reset polling counter (\n");
		exit(1);		
	};


	ret = easynmc_start_app(h, entrypoint);
	if (ret != 0) { 
		fprintf(stderr, "Failed to start app (\n");
		exit(1);
	}

	ret = 0;

	if (!g_nosigint)
		signal(SIGINT, handle_sigint);
	
	easynmc_persist_set(h, g_nosigint ? EASYNMC_PERSIST_ENABLE : EASYNMC_PERSIST_DISABLE);

	if (!g_detach) { 
		fprintf(stderr, "Application now started, hit CTRL+C to %s it\n", g_nosigint ? "detach" : "stop");
		ret = run_interactive_console(h);
	} else { 
		fprintf(stderr, "Application started, detaching\n");
	}
	
	
	if (isatty(STDIN_FILENO))
		nonblock(STDIN_FILENO,  0);

	return ret;
}
示例#30
0
/* DO NOT SAY ANYTHING. Please ;) */
int run_interactive_console(struct easynmc_handle *h)
{
	int i;
	int ret = 1;
	struct epoll_event event[3];
	struct epoll_event *events;
	int efd = epoll_create(2);
	setvbuf(stdin,NULL,_IONBF,0);

	if (efd == -1)
	{
		perror ("epoll_create");
		ret = 1;
		goto errclose;
	}
	
	int flags = fcntl(h->iofd, F_GETFL, 0);
	fcntl(h->iofd, F_SETFL, flags | O_NONBLOCK);

	if (!isatty(STDIN_FILENO)) {
		flags = fcntl(STDIN_FILENO, F_GETFL, 0);
		fcntl(h->iofd, F_SETFL, flags | O_NONBLOCK);
	} else { 
		nonblock(STDIN_FILENO,   1);
	}

	event[0].data.fd = h->iofd;
	event[0].events  = EPOLLIN | EPOLLOUT | EPOLLET;

	event[1].data.fd = h->memfd;
	event[1].events  = EPOLLNMI | EPOLLHP | EPOLLET;
	
	event[2].data.fd = STDIN_FILENO;
	event[2].events  = EPOLLIN | EPOLLET;
	
	for (i = 0; i < 3; i++) { 
		ret = epoll_ctl (efd, EPOLL_CTL_ADD, event[i].data.fd, &event[i]);
		if (ret == -1)
		{
			perror ("epoll_ctl");
			ret = 1;
			goto errclose;
		}
	}

	events = calloc (NUMEVENTS, sizeof event);
	 
	int can_read_stdin    = 0;
	int can_write_to_nmc  = 0;

	int gotfromstdin = 0; 
	int written_to_nmc = 0;
	unsigned char   tonmc[1024];
	 
	while (1) { 
		int num, i;
		num = epoll_wait(efd, events, NUMEVENTS, -1);
		for (i = 0; i < num; i++) {
			if ((events[i].data.fd == STDIN_FILENO) && (events[i].events & EPOLLIN))
				can_read_stdin=1;
			 
			if (can_read_stdin && !gotfromstdin) 
			{ 
				gotfromstdin = read(STDIN_FILENO, tonmc, 1024);
				if (isatty(STDIN_FILENO) && tonmc[0] == 3)
					die();
				
				if (-1 == gotfromstdin) { 
					perror("read-from-stdin");
					return 1;
				}
			}

			if (events[i].data.fd == h->iofd && (events[i].events & EPOLLIN)) {
				ret = read_inbound(h->iofd);
				if (ret != 0)
					return ret;
			}
			 
			if (events[i].data.fd == h->iofd && (events[i].events & EPOLLOUT)) 
				can_write_to_nmc++;
			 			 
			if ((events[i].data.fd == h->memfd) &&
			    easynmc_core_state(h) == EASYNMC_CORE_IDLE) { 
				/* 
				 * Read any bytes left in circular buffer.
				 */
				ret = read_inbound(h->iofd);
				if ( ret != 0)
					return ret;
				
				ret = easynmc_exitcode(h);				
				fprintf(stderr, "App terminated with result %d, exiting\n", ret);

				return ret;
			}

			if (can_write_to_nmc && (written_to_nmc != gotfromstdin)) {
				int n = write(h->iofd, &tonmc[written_to_nmc], 
					      gotfromstdin - written_to_nmc);

				if (n > 0) {
					written_to_nmc += n;			 
					if (written_to_nmc == gotfromstdin) {
						gotfromstdin   = 0;
						written_to_nmc = 0;
					}
				}
				else if (errno == EAGAIN) {
					break;
				} else {
					perror("write-to-nmc");
					return 1;
				}
			}
		}
	}
	
errclose:
	easynmc_close(h);
	return ret;	
}