/* For the pinentry to work correctly with SSH, we need to record the process ID * of the process communicating with the agent. That way we can get more * information about the PTS/PTY/TTY the user is on and also know whether a * DISPLAY is set for that process, because we will connect the pinentry's TTY * to the TTY of the process on the other end of the socket. */ int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) { int retval; static int (*_accept)(int, struct sockaddr *, socklen_t *) = NULL; if (_accept == NULL) _accept = dlsym(RTLD_NEXT, "accept"); retval = _accept(sockfd, addr, addrlen); last_pid = 0; #ifdef SUPERVISOR_SUPPORT if (ssh_fd == 0) gather_sd_fds(); #endif if (retval != -1 && ssh_fd != 0 && sockfd == ssh_fd) { pid_t client_pid = get_socket_pid(retval); if (client_pid == -1) { close(retval); return -1; } last_pid = client_pid; fprintf(stderr, "Socket endpoint PID for accepted socket %d is %d.\n", retval, client_pid); } return retval; }
// TODO accept an IP address to bind to AsyncMessageServer( const MessageServer::Options& opts , MessageHandler * handler ) : _port( opts.port ) , _handler(handler) , _endpoint( tcp::v4() , opts.port ) , _acceptor( _ioservice , _endpoint ) { _accept(); }
AsyncMessageServer( int port , MessageHandler * handler ) : MessageServer( port , handler ) , _endpoint( tcp::v4() , port ) , _acceptor( _ioservice , _endpoint ) { _accept(); }
void on_set(int sfd){ int client_sfd = _accept(sfd); int index = get_service_index(sfd); printf("Client requested for service %s\n", services[index].name); // if (services[index].started == 0){ // int pid = fork(); // if (pid == 0){ // char *cap = (char *)malloc(sizeof(char)*10); // sprintf(cap, "%d", services[index].capacity); // if (index == 0){ // execl(services[index].name, services[index].name, services[index].name, cap,"server", services[index+1].name,(char*)0); // } // else if (index == MAX_SERVICES -1){ // execl(services[index].name, services[index].name, services[index].name, cap,services[index-1].name, "server",(char*)0); // } // else{ // execl(services[index].name, services[index].name, services[index].name, cap,services[index-1].name, services[index+1].name,(char*)0); // } // } // else{ // services[index].unsfd = _accept(services[index].usfd); // services[index].started = 1; // } // } send_fd(services[index].usfd, client_sfd); // sending the accepted client sfd to the service. // printf("Sent the fd\n"); }
static void process_accept(kn_socket *s){ int fd; kn_sockaddr remote; for(;;) { fd = _accept(s,&remote); if(fd < 0) break; else{ handle_t h = new_stream_socket(fd,s->domain); ((kn_socket*)h)->addr_local = s->addr_local; ((kn_socket*)h)->addr_remote = remote; if(((kn_stream_socket*)s)->ctx){ ((kn_stream_socket*)h)->ssl = SSL_new(((kn_stream_socket*)s)->ctx); SSL_set_fd(((kn_stream_socket*)h)->ssl, fd); if (SSL_accept(((kn_stream_socket*)h)->ssl) == -1) { printf("SSL_accept error\n"); stream_socket_close(h); continue; } } h->status = SOCKET_ESTABLISH; ((kn_socket*)s)->callback(h,s,0,0); } } }
Socket* TLSSocket::accept() { string inf; Fd connFd = _accept(inf); if (connFd == -1) throw SocketExcept("accept failed"); return new TLSSocket(connFd, *this, inf); }
static void tcp_accept_callback( const int lst ) { D(bug("[%d] tcp_accept_callback()\r\n", lst)); struct sockaddr_in to; memset( &to, 0, sizeof(to) ); to.sin_family = AF_INET; int tolen = sizeof(to); SOCKET s = _accept( l_sockets[lst].s, (struct sockaddr *)&to, &tolen ); if( s == INVALID_SOCKET ) { D(bug("[%d] connection not accepted, error code %d\r\n", lst, _WSAGetLastError())); } else { _WSAEventSelect( s, 0, 0 ); uint16 src_port = l_sockets[lst].port; uint16 dest_port = ntohs(to.sin_port); uint32 ip_dest = ntohl(to.sin_addr.s_addr); D(bug("[%d] connection accepted, local port:%d, remote %s:%d\r\n", lst, src_port, _inet_ntoa(to.sin_addr), dest_port)); if( l_sockets[lst].ip != 0 && l_sockets[lst].ip != ip_dest ) { _closesocket( s ); D(bug("[%d] authorization failure. connection closed.\r\n", lst )); } else { int t = alloc_new_socket( src_port, dest_port, ip_dest ); if( t < 0 ) { D(bug("<%d> out of slot space, connection dropped\r\n", t )); free_socket(t); } else { sockets[t].s = s; sockets[t].state = LISTEN; sockets[t].src_port = src_port; sockets[t].dest_port = dest_port; sockets[t].ip_src = macos_ip_address; sockets[t].ip_dest = ip_dest; sockets[t].seq_out = 0x00000001; sockets[t].seq_in = 0; // not known yet sockets[t].mac_ack = sockets[t].seq_out; // zero out pending bytes tcp_reply( SYN, t ); sockets[t].seq_out++; sockets[t].state = SYN_SENT; sockets[t].time_wait = GetTickCount() + SYN_FLOOD_PROTECTION_TIMEOUT; D(bug("<%d> Connect: LISTEN -> SYN_SENT\r\n", t)); _WSAResetEvent( sockets[t].ev ); if( SOCKET_ERROR == _WSAEventSelect( sockets[t].s, sockets[t].ev, FD_CLOSE ) ) { D(bug("<%d> WSAEventSelect() failed with error code %d\r\n", t, _WSAGetLastError())); } // No data from the remote host is needed until the connection is established. // So don't initiate read yet. } } } }
void handleAccept( shared_ptr<MessageServerSession> session , const boost::system::error_code& error ){ if ( error ){ cout << "handleAccept error!" << endl; return; } session->start(); _accept(); }
void _callback(int fd, short which, void* v) { (void)which; int new_fd = _accept(fd); if (new_fd != -1) { AcceptService* service = (AcceptService*)v; service->run(new_fd); } }
PRInt32 _MD_accept(PRInt32 osfd, PRNetAddr *addr, PRInt32 addrlen, PRIntervalTime timeout) { PRInt32 rv; _MD_BLOCK_CLOCK_INTERRUPTS(); rv = _accept(osfd,addr,addrlen); _MD_UNBLOCK_CLOCK_INTERRUPTS(); return(rv); }
int accept(int s, struct sockaddr *addr, int *addrlen) { int a; if ((a = _accept(s, addr, addrlen)) == -1) { if (errno == N_AGAIN) errno = EWOULDBLOCK; else maperror(errno); } return (a); }
/********************************************************************* * * _Accept * * Function description * This function is called from the FTP server module if the client * uses passive FTP. It sets the command socket to non-blocking before * accept() will be called. This guarantees that the FTP server always * returns even if the connection to the client gets lost while * accept() waits for a connection. The timeout is set to 10 seconds. * * Return value * 0 O.K. * -1 Error */ static int _Accept(FTPS_SOCKET CtrlSocket, FTPS_SOCKET * pSocket) { int Socket; int DataSock; int SoError; int t0; int t; struct sockaddr Addr; int AddrSize; int Opt; AddrSize = sizeof(Addr); Socket = *(int*)pSocket; // // Set command socket non-blocking // Opt = 1; setsockopt(Socket, SOL_SOCKET, SO_NONBLOCK, &Opt, sizeof(Opt)); t0 = IP_OS_GetTime32(); do { DataSock = _accept(Socket, &Addr, &AddrSize); if (DataSock != SOCKET_ERROR) { // // Set command socket blocking // Opt = 0; setsockopt(Socket, SOL_SOCKET, SO_NONBLOCK, &Opt, sizeof(Opt)); // // Set data socket blocking. The data socket inherits the blocking // mode from the socket that was used as parameter for accept(). // Therefore, we have to set it blocking after creation. // SO_KEEPALIVE is required to quarantee that the socket will be // closed even if the client has lost the connection to server // before he closed the connection. // setsockopt(DataSock, SOL_SOCKET, SO_NONBLOCK, &Opt, sizeof(Opt)); Opt=1; setsockopt(DataSock, SOL_SOCKET, SO_KEEPALIVE, &Opt, sizeof(Opt)); *pSocket = (FTPS_SOCKET)DataSock; return 0; // Successfully connected } getsockopt(Socket, SOL_SOCKET, SO_ERROR, &SoError, sizeof(SoError)); if (SoError != EWOULDBLOCK) { return SOCKET_ERROR; // Not in progress and not successful, error... } t = IP_OS_GetTime32() - t0; if (t >= 10000) { return SOCKET_ERROR; } OS_Delay(1); // Give lower prior tasks some time } while (1); }
int socket_accept(int fd, char *ip, size_t ip_len, int *port) { int s; struct sockaddr_storage sa; socklen_t salen = sizeof(sa); s = _accept(fd, (struct sockaddr*)&sa, &salen); if (s == CORVUS_AGAIN || s == CORVUS_ERR) return s; struct sockaddr_in *addr = (struct sockaddr_in*)&sa; if (ip) inet_ntop(AF_INET, (void*)&(addr->sin_addr), ip, ip_len); if (port) *port = ntohs(addr->sin_port); return s; }
void triviaServer::serve(struct addrinfo* a) { bindAndListen(a); std::thread(&triviaServer::handleRecievedMessages, this).detach(); while (true) { try { _accept(listenSocket); } catch (std::exception &e) { std::cout << e.what() << std::endl; } } }
static void process_accept(chk_handle *h,int32_t events) { int32_t fd; int32_t ret; chk_sockaddr addr; chk_acceptor *acceptor = cast(chk_acceptor*,h); if(events == CHK_EVENT_LOOPCLOSE){ acceptor->cb(acceptor,-1,NULL,acceptor->ud,chk_error_loop_close); return; } do { ret = _accept(acceptor,&addr,&fd); if(ret == 0) acceptor->cb(acceptor,fd,&addr,acceptor->ud,0); else if(ret != EAGAIN) acceptor->cb(acceptor,-1,NULL,acceptor->ud,chk_error_accept); }while(0 == ret && chk_is_read_enable(h)); }
void tcp_basesession::on_accept( tcp_server* p ) { p->increase_connection_count(); m_isconnected = true; m_last_action_time = (unsigned int)time( NULL ); m_father = p; m_dsv.reset(); _accept(); //m_send_crypt_key = rand() % 255 + 1; //m_recv_crypt_key = m_send_crypt_key; //send_message( &m_send_crypt_key, 1 ); _read_next_message(); m_thread_index = p->generate_thread_index(); m_remote_ip_str = get_remote_address_string(); m_remote_ip_ui = get_remote_address_ui(); _record_action(); }
void process_accept(socket_t s) { SOCK client; //struct sockaddr_in ClientAddress; socklen_t len = sizeof(s->addr_remote); while(1) { client = _accept(s, (struct sockaddr*)&s->addr_remote,&len); if (client == INVALID_SOCK) break; else{ socket_t _client = (socket_t)client; len = sizeof(_client->addr_local); getpeername(_client->fd,(struct sockaddr*)&_client->addr_remote,&len); getsockname(_client->fd,(struct sockaddr*)&_client->addr_local,&len); s->on_accept(client,&_client->addr_remote,s->ud); } } }
void accept() { _accept(); }
VisitorResult Server::accept( ServerVisitor& visitor ) const { return _accept( this, visitor ); }
VisitorResult Config::_acceptCompounds( ConfigVisitor& visitor ) const { return _accept( this, visitor ); }
/*ARGSUSED*/ static bool_t rendezvous_request(SVCXPRT *xprt, struct rpc_msg *msg) { int sock, flags; struct cf_rendezvous *r; struct cf_conn *cd; struct sockaddr_storage addr; socklen_t len; struct __rpc_sockinfo si; SVCXPRT *newxprt; fd_set cleanfds; assert(xprt != NULL); assert(msg != NULL); r = (struct cf_rendezvous *)xprt->xp_p1; again: len = sizeof addr; if ((sock = _accept(xprt->xp_fd, (struct sockaddr *)(void *)&addr, &len)) < 0) { if (errno == EINTR) goto again; /* * Clean out the most idle file descriptor when we're * running out. */ if (errno == EMFILE || errno == ENFILE) { cleanfds = svc_fdset; __svc_clean_idle(&cleanfds, 0, FALSE); goto again; } return (FALSE); } /* * make a new transporter (re-uses xprt) */ newxprt = makefd_xprt(sock, r->sendsize, r->recvsize); newxprt->xp_rtaddr.buf = mem_alloc(len); if (newxprt->xp_rtaddr.buf == NULL) return (FALSE); memcpy(newxprt->xp_rtaddr.buf, &addr, len); newxprt->xp_rtaddr.len = len; #ifdef PORTMAP if (addr.ss_family == AF_INET || addr.ss_family == AF_LOCAL) { newxprt->xp_raddr = *(struct sockaddr_in *)newxprt->xp_rtaddr.buf; newxprt->xp_addrlen = sizeof (struct sockaddr_in); } #endif /* PORTMAP */ if (__rpc_fd2sockinfo(sock, &si) && si.si_proto == IPPROTO_TCP) { len = 1; /* XXX fvdl - is this useful? */ _setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &len, sizeof (len)); } cd = (struct cf_conn *)newxprt->xp_p1; cd->recvsize = r->recvsize; cd->sendsize = r->sendsize; cd->maxrec = r->maxrec; if (cd->maxrec != 0) { flags = _fcntl(sock, F_GETFL, 0); if (flags == -1) return (FALSE); if (_fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) return (FALSE); if (cd->recvsize > cd->maxrec) cd->recvsize = cd->maxrec; cd->nonblock = TRUE; __xdrrec_setnonblock(&cd->xdrs, cd->maxrec); } else cd->nonblock = FALSE; gettimeofday(&cd->last_recv_time, NULL); return (FALSE); /* there is never an rpc msg to be processed */ }
static VALUE rhe_accept(VALUE self, VALUE fileno, VALUE timeoutv, VALUE tcp, VALUE env) { struct sockaddr_in cliaddr; unsigned int len; char read_buf[MAX_HEADER_SIZE]; VALUE req; int flag = 1; ssize_t rv = 0; ssize_t buf_len; ssize_t reqlen; int fd; double timeout = NUM2DBL(timeoutv); len = sizeof(cliaddr); fd = _accept(NUM2INT(fileno), (struct sockaddr *)&cliaddr, len); /* endif */ if (fd < 0) { goto badexit; } rv = _read_timeout(fd, timeout, &read_buf[0], MAX_HEADER_SIZE); if ( rv <= 0 ) { close(fd); goto badexit; } if ( IMMEDIATE_P(tcp) ) { setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int)); rb_hash_aset(env, remote_addr_key, rb_str_new2(inet_ntoa(cliaddr.sin_addr))); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(ntohs(cliaddr.sin_port)))); } else { rb_hash_aset(env, remote_addr_key, rb_str_new("",0)); rb_hash_aset(env, remote_port_key, rb_String(rb_int_new(0))); } buf_len = rv; while (1) { reqlen = _parse_http_request(&read_buf[0],buf_len,env); if ( reqlen >= 0 ) { break; } else if ( reqlen == -1 ) { /* error */ close(fd); goto badexit; } if ( MAX_HEADER_SIZE - buf_len == 0 ) { /* too large header */ char* badreq; badreq = BAD_REQUEST; rv = _write_timeout(fd, timeout, badreq, sizeof(BAD_REQUEST) - 1); close(fd); goto badexit; } /* request is incomplete */ rv = _read_timeout(fd, timeout, &read_buf[buf_len], MAX_HEADER_SIZE - buf_len); if ( rv <= 0 ) { close(fd); goto badexit; } buf_len += rv; } req = rb_ary_new2(3); rb_ary_push(req, rb_int_new(fd)); rb_ary_push(req, rb_str_new(&read_buf[reqlen],buf_len - reqlen)); return req; badexit: return Qnil; }
static BOOL freerdp_listener_check_fds(freerdp_listener* instance) { int i; void* sin_addr; int peer_sockfd; freerdp_peer* client = NULL; int peer_addr_size; struct sockaddr_storage peer_addr; rdpListener* listener = (rdpListener*) instance->listener; static const BYTE localhost6_bytes[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }; BOOL peer_accepted; if (listener->num_sockfds < 1) return FALSE; for (i = 0; i < listener->num_sockfds; i++) { WSAResetEvent(listener->events[i]); peer_addr_size = sizeof(peer_addr); peer_sockfd = _accept(listener->sockfds[i], (struct sockaddr*) &peer_addr, &peer_addr_size); peer_accepted = FALSE; if (peer_sockfd == -1) { #ifdef _WIN32 int wsa_error = WSAGetLastError(); /* No data available */ if (wsa_error == WSAEWOULDBLOCK) continue; #else if (errno == EAGAIN || errno == EWOULDBLOCK) continue; #endif WLog_DBG(TAG, "accept"); free(client); return FALSE; } client = freerdp_peer_new(peer_sockfd); if (!client) { closesocket((SOCKET) peer_sockfd); return FALSE; } sin_addr = NULL; if (peer_addr.ss_family == AF_INET) { sin_addr = &(((struct sockaddr_in*) &peer_addr)->sin_addr); if ((*(UINT32*) sin_addr) == 0x0100007f) client->local = TRUE; } else if (peer_addr.ss_family == AF_INET6) { sin_addr = &(((struct sockaddr_in6*) &peer_addr)->sin6_addr); if (memcmp(sin_addr, localhost6_bytes, 16) == 0) client->local = TRUE; } #ifndef _WIN32 else if (peer_addr.ss_family == AF_UNIX) client->local = TRUE; #endif if (sin_addr) inet_ntop(peer_addr.ss_family, sin_addr, client->hostname, sizeof(client->hostname)); IFCALLRET(instance->PeerAccepted, peer_accepted, instance, client); if (!peer_accepted) { WLog_ERR(TAG, "PeerAccepted callback failed"); closesocket((SOCKET) peer_sockfd); freerdp_peer_free(client); } } return TRUE; }
int rcmd_af(char **ahost, int rport, const char *locuser, const char *remuser, const char *cmd, int *fd2p, int af) { struct addrinfo hints, *res, *ai; struct sockaddr_storage from; fd_set reads; sigset_t oldmask, newmask; pid_t pid; int s, aport, lport, timo, error; char c, *p; int refused, nres; char num[8]; static char canonnamebuf[MAXDNAME]; /* is it proper here? */ /* call rcmdsh() with specified remote shell if appropriate. */ if (!issetugid() && (p = getenv("RSH"))) { struct servent *sp = getservbyname("shell", "tcp"); if (sp && sp->s_port == rport) return (rcmdsh(ahost, rport, locuser, remuser, cmd, p)); } /* use rsh(1) if non-root and remote port is shell. */ if (geteuid()) { struct servent *sp = getservbyname("shell", "tcp"); if (sp && sp->s_port == rport) return (rcmdsh(ahost, rport, locuser, remuser, cmd, NULL)); } pid = getpid(); memset(&hints, 0, sizeof(hints)); hints.ai_flags = AI_CANONNAME; hints.ai_family = af; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; snprintf(num, sizeof(num), "%d", ntohs(rport)); error = getaddrinfo(*ahost, num, &hints, &res); if (error) { fprintf(stderr, "rcmd: getaddrinfo: %s\n", gai_strerror(error)); if (error == EAI_SYSTEM) fprintf(stderr, "rcmd: getaddrinfo: %s\n", strerror(errno)); return (-1); } if (res->ai_canonname && strlen(res->ai_canonname) + 1 < sizeof(canonnamebuf)) { strncpy(canonnamebuf, res->ai_canonname, sizeof(canonnamebuf)); *ahost = canonnamebuf; } nres = 0; for (ai = res; ai; ai = ai->ai_next) nres++; ai = res; refused = 0; sigemptyset(&newmask); sigaddset(&newmask, SIGURG); _sigprocmask(SIG_BLOCK, (const sigset_t *)&newmask, &oldmask); for (timo = 1, lport = IPPORT_RESERVED - 1;;) { s = rresvport_af(&lport, ai->ai_family); if (s < 0) { if (errno != EAGAIN && ai->ai_next) { ai = ai->ai_next; continue; } if (errno == EAGAIN) fprintf(stderr, "rcmd: socket: All ports in use\n"); else fprintf(stderr, "rcmd: socket: %s\n", strerror(errno)); freeaddrinfo(res); _sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL); return (-1); } _fcntl(s, F_SETOWN, pid); if (_connect(s, ai->ai_addr, ai->ai_addrlen) >= 0) break; _close(s); if (errno == EADDRINUSE) { lport--; continue; } if (errno == ECONNREFUSED) refused = 1; if (ai->ai_next == NULL && (!refused || timo > 16)) { fprintf(stderr, "%s: %s\n", *ahost, strerror(errno)); freeaddrinfo(res); _sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL); return (-1); } if (nres > 1) { int oerrno = errno; getnameinfo(ai->ai_addr, ai->ai_addrlen, paddr, sizeof(paddr), NULL, 0, NI_NUMERICHOST); fprintf(stderr, "connect to address %s: ", paddr); errno = oerrno; perror(0); } if ((ai = ai->ai_next) == NULL) { /* refused && timo <= 16 */ struct timespec time_to_sleep, time_remaining; time_to_sleep.tv_sec = timo; time_to_sleep.tv_nsec = 0; _nanosleep(&time_to_sleep, &time_remaining); timo *= 2; ai = res; refused = 0; } if (nres > 1) { getnameinfo(ai->ai_addr, ai->ai_addrlen, paddr, sizeof(paddr), NULL, 0, NI_NUMERICHOST); fprintf(stderr, "Trying %s...\n", paddr); } } lport--; if (fd2p == 0) { _write(s, "", 1); lport = 0; } else { int s2 = rresvport_af(&lport, ai->ai_family), s3; socklen_t len = ai->ai_addrlen; int nfds; if (s2 < 0) goto bad; _listen(s2, 1); snprintf(num, sizeof(num), "%d", lport); if (_write(s, num, strlen(num)+1) != strlen(num)+1) { fprintf(stderr, "rcmd: write (setting up stderr): %s\n", strerror(errno)); _close(s2); goto bad; } nfds = max(s, s2)+1; if(nfds > FD_SETSIZE) { fprintf(stderr, "rcmd: too many files\n"); _close(s2); goto bad; } again: FD_ZERO(&reads); FD_SET(s, &reads); FD_SET(s2, &reads); errno = 0; if (_select(nfds, &reads, 0, 0, 0) < 1 || !FD_ISSET(s2, &reads)){ if (errno != 0) fprintf(stderr, "rcmd: select (setting up stderr): %s\n", strerror(errno)); else fprintf(stderr, "select: protocol failure in circuit setup\n"); _close(s2); goto bad; } s3 = _accept(s2, (struct sockaddr *)&from, &len); switch (from.ss_family) { case AF_INET: aport = ntohs(((struct sockaddr_in *)&from)->sin_port); break; #ifdef INET6 case AF_INET6: aport = ntohs(((struct sockaddr_in6 *)&from)->sin6_port); break; #endif default: aport = 0; /* error */ break; } /* * XXX careful for ftp bounce attacks. If discovered, shut them * down and check for the real auxiliary channel to connect. */ if (aport == 20) { _close(s3); goto again; } _close(s2); if (s3 < 0) { fprintf(stderr, "rcmd: accept: %s\n", strerror(errno)); lport = 0; goto bad; } *fd2p = s3; if (aport >= IPPORT_RESERVED || aport < IPPORT_RESERVED / 2) { fprintf(stderr, "socket: protocol failure in circuit setup.\n"); goto bad2; } } _write(s, locuser, strlen(locuser)+1); _write(s, remuser, strlen(remuser)+1); _write(s, cmd, strlen(cmd)+1); if (_read(s, &c, 1) != 1) { fprintf(stderr, "rcmd: %s: %s\n", *ahost, strerror(errno)); goto bad2; } if (c != 0) { while (_read(s, &c, 1) == 1) { _write(STDERR_FILENO, &c, 1); if (c == '\n') break; } goto bad2; } _sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL); freeaddrinfo(res); return (s); bad2: if (lport) _close(*fd2p); bad: _close(s); _sigprocmask(SIG_SETMASK, (const sigset_t *)&oldmask, NULL); freeaddrinfo(res); return (-1); }
bool EthernetServer::hasClient() { _accept(); return !new_clients.empty(); }