自学教程：C++ sock_errno函数代码示例

intcheck_connection_completion(int fd){    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);    struct pollfd pfd;    int retval;    pfd.fd = fd;    pfd.events = POLLOUT;#ifndef _WIN32    do {        retval = poll(&pfd, 1, 0);    } while (retval < 0 && errno == EINTR);#else    retval = WSAPoll(&pfd, 1, 0);#endif    if (retval == 1) {        if (pfd.revents & POLLERR) {            ssize_t n = send(fd, "", 1, 0);            if (n < 0) {                return sock_errno();            } else {                VLOG_ERR_RL(&rl, "poll return POLLERR but send succeeded");                return EPROTO;            }        }        return 0;    } else if (retval < 0) {        VLOG_ERR_RL(&rl, "poll: %s", sock_strerror(sock_errno()));        return errno;    } else {        return EAGAIN;    }}

void acceptex_thread(){      long sock_accex, recvd = 0;      long locallen,clilen;      char *Outbuff;      int alloc = 1024;      struct sockaddr_in local;      struct sockaddr_in cli_addr;      locallen = sizeof(local);      clilen = sizeof(cli_addr);      Outbuff = (char*) malloc( alloc );      if (Outbuff == NULL) {        printf("malloc error");        total_threads++;        exit(0);      }Begin:      sock_accex = -1;      recvd = accept_and_recv(sockfd,&sock_accex,(struct sockaddr *)&cli_addr, &clilen,(struct sockaddr *)&local,&locallen,Outbuff,alloc);      if(recvd < 0)        {           printf("error in acceptex recv= %d/n",sock_errno());           total_threads++;           goto Begin;           locallen = sizeof(local);           clilen = sizeof(cli_addr);           alloc =1024;           recvd = accept_and_recv(sockfd,&sock_accex,(struct sockaddr *)&cli_addr, &clilen,(struct sockaddr *)&local,&locallen,Outbuff,alloc);              if(recvd < 0)                {                   printf("error in acceptex recv= %d/n",sock_errno());        }        else        {              locallen = sizeof(local);              clilen = sizeof(cli_addr);              alloc =1024;              recvd = accept_and_recv(sockfd,&sock_accex,(struct sockaddr *)&cli_addr, &clilen,(struct sockaddr *)&local,&locallen,Outbuff,alloc);              if(recvd < 0)                   printf("error in acceptex recv= %d/n",sock_errno());        }}       printf(" Local addr :%x, Local_addr_len :%d/n",local.sin_addr.s_addr,locallen);       printf(" Bytes recieved with acceptex :%d/n",recvd);       printf(" Msg recvd with acceptex :%s/n",Outbuff);       printf(" Recv socket Id :%d/n",sock_accex);       printf("Before soclose/n");       soclose(sock_accex);       printf("after soclose/n");       total_threads++;       return ;}

static int packet_socket(struct sock *sk, int type, int proto){	struct packet_priv *priv = rte_malloc(NULL, sizeof(*sk->priv), 0);	if (!priv)		return sock_errno(sk, ENOMEM);	priv->type = type;	sk->priv = priv;	return sock_errno(sk, 0);}

intcheck_connection_completion(int fd){    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 10);    struct pollfd pfd;    int retval;    pfd.fd = fd;    pfd.events = POLLOUT;#ifndef _WIN32    do {        retval = poll(&pfd, 1, 0);    } while (retval < 0 && errno == EINTR);#else    fd_set wrset, exset;    FD_ZERO(&wrset);    FD_ZERO(&exset);    FD_SET(fd, &exset);    FD_SET(fd, &wrset);    pfd.revents = 0;    struct timeval tv = { 0, 0 };    /* WSAPoll is broken on Windows, instead do a select */    retval = select(0, NULL, &wrset, &exset, &tv);    if (retval == 1) {        if (FD_ISSET(fd, &wrset)) {            pfd.revents |= pfd.events;        }        if (FD_ISSET(fd, &exset)) {            pfd.revents |= POLLERR;        }    }#endif    if (retval == 1) {        if (pfd.revents & POLLERR) {            ssize_t n = send(fd, "", 1, 0);            if (n < 0) {                return sock_errno();            } else {                VLOG_ERR_RL(&rl, "poll return POLLERR but send succeeded");                return EPROTO;            }        }        return 0;    } else if (retval < 0) {        VLOG_ERR_RL(&rl, "poll: %s", sock_strerror(sock_errno()));        return errno;    } else {        return EAGAIN;    }}

APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t *sock,                                            const struct iovec *vec,                                            apr_int32_t nvec, apr_size_t *len){    apr_status_t rv;    struct iovec *tmpvec;    int fds, err = 0;    int nv_tosend, total = 0;    /* Make sure writev() only gets fed 64k at a time */    for ( nv_tosend = 0; nv_tosend < nvec && total + vec[nv_tosend].iov_len < 65536; nv_tosend++ ) {        total += vec[nv_tosend].iov_len;    }    tmpvec = alloca(sizeof(struct iovec) * nv_tosend);    memcpy(tmpvec, vec, sizeof(struct iovec) * nv_tosend);    do {        if (!sock->nonblock || err == SOCEWOULDBLOCK) {            fds = sock->socketdes;            rv = select(&fds, 0, 1, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);            if (rv != 1) {                *len = 0;                err = sock_errno();                if (rv == 0)                    return APR_TIMEUP;                if (err == SOCEINTR)                    continue;                return APR_OS2_STATUS(err);            }        }        rv = writev(sock->socketdes, tmpvec, nv_tosend);        err = rv < 0 ? sock_errno() : 0;    } while (err == SOCEINTR || err == SOCEWOULDBLOCK);    if (err) {        *len = 0;        return APR_OS2_STATUS(err);    }    *len = rv;    return APR_SUCCESS;}

static inttlso_bio_read( BIO *b, char *buf, int len ){	struct tls_data		*p;	int			ret;			if ( buf == NULL || len <= 0 ) return 0;	p = (struct tls_data *)BIO_get_data(b);	if ( p == NULL || p->sbiod == NULL ) {		return 0;	}	ret = LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );	BIO_clear_retry_flags( b );	if ( ret < 0 ) {		int err = sock_errno();		if ( err == EAGAIN || err == EWOULDBLOCK ) {			BIO_set_retry_read( b );		}	}	return ret;}

/* protected by conn_mutex */intldap_int_flush_request(	LDAP *ld,	LDAPRequest *lr ){	LDAPConn *lc = lr->lr_conn;	LDAP_ASSERT_MUTEX_OWNER( &ld->ld_conn_mutex );	if ( ber_flush2( lc->lconn_sb, lr->lr_ber, LBER_FLUSH_FREE_NEVER ) != 0 ) {		if ( sock_errno() == EAGAIN ) {			/* need to continue write later */			lr->lr_status = LDAP_REQST_WRITING;			ldap_mark_select_write( ld, lc->lconn_sb );			ld->ld_errno = LDAP_BUSY;			return -2;		} else {			ld->ld_errno = LDAP_SERVER_DOWN;			ldap_free_request( ld, lr );			ldap_free_connection( ld, lc, 0, 0 );			return( -1 );		}	} else {		if ( lr->lr_parent == NULL ) {			lr->lr_ber->ber_end = lr->lr_ber->ber_ptr;			lr->lr_ber->ber_ptr = lr->lr_ber->ber_buf;		}		lr->lr_status = LDAP_REQST_INPROGRESS;		/* sent -- waiting for a response */		ldap_mark_select_read( ld, lc->lconn_sb );		ldap_clear_select_write( ld, lc->lconn_sb );	}	return 0;}

/* * xstrerror() - sock_errno/strerror-like wrapper */const char *xstrerror_a(void){   int ierr;    ierr = sock_errno();    return xbstrerror_i(ierr);}

static intnew_tcp_stream(const char *name, int fd, int connect_status,               struct stream **streamp){    struct sockaddr_storage local;    socklen_t local_len = sizeof local;    int on = 1;    int retval;    /* Get the local IP and port information */    retval = getsockname(fd, (struct sockaddr *) &local, &local_len);    if (retval) {        memset(&local, 0, sizeof local);    }    retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);    if (retval) {        int error = sock_errno();        VLOG_ERR("%s: setsockopt(TCP_NODELAY): %s",                 name, sock_strerror(error));        close(fd);        return error;    }    return new_fd_stream(name, fd, connect_status, streamp);}

static int packet_bind(struct sock *sk, const struct sockaddr *a, socklen_t addrlen){	struct sockaddr_ll *addr = (struct sockaddr_ll *)a;	struct net_device *dev = NULL;	if (addrlen != sizeof(*addr))		return sock_errno(sk, EINVAL);	if (addr->sll_ifindex) {		dev = netdev_get_by_index(addr->sll_ifindex);		if (!dev)			return sock_errno(sk, ENODEV);	}	return sock_errno(sk, 0);}

/* Sets the DSCP value of socket 'fd' to 'dscp', which must be 63 or less. * 'family' must indicate the socket's address family (AF_INET or AF_INET6, to * do anything useful). */intset_dscp(int fd, int family, uint8_t dscp){    int retval;    int val;#ifdef _WIN32    /* XXX: Consider using QoS2 APIs for Windows to set dscp. */    return 0;#endif    if (dscp > 63) {        return EINVAL;    }    val = dscp << 2;    switch (family) {    case AF_INET:        retval = setsockopt(fd, IPPROTO_IP, IP_TOS, &val, sizeof val);        break;    case AF_INET6:        retval = setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &val, sizeof val);        break;    default:        return ENOPROTOOPT;    }    return retval ? sock_errno() : 0;}

/* Converts a string containing a valid internet address using   dotted-decimal notation or host name into an internet address   number typed as an unsigned long value.  A -1 value   indicates an error. */u_long XIOsocket::get_address(const char* hostname){  u_long address;  struct hostent* entry;  if (!hostname)  { errno = HBASEERR + HOST_NOT_FOUND;    return (u_long)-1L;  }  if ((address = inet_addr((char*)hostname)) == (u_long)-1L)  { if ((entry = gethostbyname((char*)hostname)) != NULL)    { memcpy( &address, entry->h_addr, sizeof( address ));    } else    {      #ifdef NETDB_INTERNAL      if (h_errno == NETDB_INTERNAL)        errno = sock_errno();      else      #endif        errno = h_errno + HBASEERR;    }  }  return address;}

static inttlso_bio_write( BIO *b, const char *buf, int len ){	struct tls_data		*p;	int			ret;		if ( buf == NULL || len <= 0 ) return 0;		p = (struct tls_data *)b->ptr;	if ( p == NULL || p->sbiod == NULL ) {		return 0;	}	ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );	BIO_clear_retry_flags( b );	if ( ret < 0 ) {		int err = sock_errno();		if ( err == EAGAIN || err == EWOULDBLOCK ) {			BIO_set_retry_write( b );		}	}	return ret;}

static ber_slen_tsb_debug_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len ){	ber_slen_t		ret;	char ebuf[128];	ret = LBER_SBIOD_WRITE_NEXT( sbiod, buf, len );	if (sbiod->sbiod_sb->sb_debug & LDAP_DEBUG_PACKETS) {		int err = sock_errno();		if ( ret < 0 ) {			ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,				"%swrite: want=%ld error=%s/n",				(char *)sbiod->sbiod_pvt, (long)len,				AC_STRERROR_R( err, ebuf, sizeof ebuf ) );		} else {			ber_log_printf( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,				"%swrite: want=%ld, written=%ld/n",				(char *)sbiod->sbiod_pvt, (long)len, (long)ret );			ber_log_bprint( LDAP_DEBUG_PACKETS, sbiod->sbiod_sb->sb_debug,				(const char *)buf, ret );		}		sock_errset(err);	}	return ret;}

/* Sets 'fd' to non-blocking mode.  Returns 0 if successful, otherwise a * positive errno value. */intset_nonblocking(int fd){#ifndef _WIN32    int flags = fcntl(fd, F_GETFL, 0);    if (flags != -1) {        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1) {            return 0;        } else {            VLOG_ERR("fcntl(F_SETFL) failed: %s", ovs_strerror(errno));            return errno;        }    } else {        VLOG_ERR("fcntl(F_GETFL) failed: %s", ovs_strerror(errno));        return errno;    }#else    unsigned long arg = 1;    if (ioctlsocket(fd, FIONBIO, &arg)) {        int error = sock_errno();        VLOG_ERR("set_nonblocking failed: %s", sock_strerror(error));        return error;    }    return 0;#endif}

ber_slen_tber_int_sb_write( Sockbuf *sb, void *buf, ber_len_t len ){    ber_slen_t		ret;    assert( buf != NULL );    assert( sb != NULL);    assert( sb->sb_iod != NULL );    assert( SOCKBUF_VALID( sb ) );    for (;;) {        ret = sb->sb_iod->sbiod_io->sbi_write( sb->sb_iod, buf, len );#ifdef EINTR        if ( ret < 0 )        {#ifdef HAVE_WINSOCK     // on Windows, errno is NOT set by send call automatically.            if ( (errno = sock_errno()) == WSAEINTR)            {                errno = EINTR;            }#endif            if( errno == EINTR )  continue;        }#endif        break;    }    return ret;}

/* Receives bytes on a socket up to the first new-line character (/n)   or until the number of bytes received is equal to n-1, whichever   comes first. Stores the result in string and adds a null   character (/0) to the end of the string. If n is equal to 1, the   string is empty. Returns a pointer to the string buffer if successful.   A NULL return value indicates an error or that the connection is   closed.*/char* XIOsocket::gets(char* buffer, unsigned int size){  unsigned int done = 0;  char* p  = buffer;  DEBUGLOG(("XIOsocket(%p{%d})::gets(%p, %d)/n", this, s_handle, buffer, size));  while (done < size - 1)  {    #ifdef TCPV40HDRS    // Work around for missing SO_RCVTIMEO in 16 bit IP stack.    struct timeval timeout = {0};    timeout.tv_sec = xio_socket_timeout();    if (timeout.tv_sec)    { fd_set waitlist;      FD_ZERO(&waitlist);      FD_SET (s_handle, &waitlist);      switch (select(s_handle+1, &waitlist, NULL, NULL, &timeout))      { case 0: // Timeout          seterror(SOCETIMEDOUT);          return NULL;        case -1: // Error          seterror();          return NULL;      }    }    #endif    int rc = recv(s_handle, p, 1, 0);    if( rc == 1 )    { if (*p == '/r')        continue;      else if(*p == '/n')        break;      else      { ++p;        ++done;      }    } else    { DEBUGLOG(("XIOsocket::gets: error %d/n", sock_errno()));      if (!done)      { if (rc == 0)          eof = true;        else          seterror();        return NULL;      } else        break;    }  }  *p = 0;  DEBUGLOG(("XIOsocket::gets: %s/n", buffer));  return buffer;}

/* Translates 'host_name', which must be a host name or a string representation * of an IP address, into a numeric IP address in '*addr'.  Returns 0 if * successful, otherwise a positive errno value. * * Most Open vSwitch code should not use this because it causes deadlocks: * getaddrinfo() sends out a DNS request but that starts a new flow for which * OVS must set up a flow, but it can't because it's waiting for a DNS reply. * The synchronous lookup also delays other activity.  (Of course we can solve * this but it doesn't seem worthwhile quite yet.)  */intlookup_hostname(const char *host_name, struct in_addr *addr){    struct addrinfo *result;    struct addrinfo hints;    if (ip_parse(host_name, &addr->s_addr)) {        return 0;    }    memset(&hints, 0, sizeof hints);    hints.ai_family = AF_INET;    switch (getaddrinfo(host_name, NULL, &hints, &result)) {    case 0:        *addr = ALIGNED_CAST(struct sockaddr_in *,                             result->ai_addr)->sin_addr;        freeaddrinfo(result);        return 0;#ifdef EAI_ADDRFAMILY    case EAI_ADDRFAMILY:#endif    case EAI_NONAME:    case EAI_SERVICE:        return ENOENT;    case EAI_AGAIN:        return EAGAIN;    case EAI_BADFLAGS:    case EAI_FAMILY:    case EAI_SOCKTYPE:        return EINVAL;    case EAI_FAIL:        return EIO;    case EAI_MEMORY:        return ENOMEM;#if defined (EAI_NODATA) && EAI_NODATA != EAI_NONAME    case EAI_NODATA:        return ENXIO;#endif#ifdef EAI_SYSTEM    case EAI_SYSTEM:        return sock_errno();#endif    default:        return EPROTO;    }}

PRStatus _MD_OS2GetHostName(char *name, PRUint32 namelen){    PRIntn rv;    rv = gethostname(name, (PRInt32) namelen);    if (0 == rv) {        return PR_SUCCESS;    }	_PR_MD_MAP_GETHOSTNAME_ERROR(sock_errno());    return PR_FAILURE;}

APR_DECLARE(apr_status_t) apr_socket_atmark(apr_socket_t *sock, int *atmark){    int oobmark;    if (ioctl(sock->socketdes, SIOCATMARK, (void*)&oobmark, sizeof(oobmark)) < 0) {        return APR_OS2_STATUS(sock_errno());    }    *atmark = (oobmark != 0);    return APR_SUCCESS;}

voidsetsockopt_tcp_nodelay(int fd){    int on = 1;    int retval;    retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);    if (retval) {        retval = sock_errno();        VLOG_ERR("setsockopt(TCP_NODELAY): %s", sock_strerror(retval));    }}

APR_DECLARE(apr_status_t) apr_socket_recvfrom(apr_sockaddr_t *from,                                              apr_socket_t *sock,                                              apr_int32_t flags, char *buf,                                              apr_size_t *len){    apr_ssize_t rv;    int serrno;    do {        rv = recvfrom(sock->socketdes, buf, (*len), flags,                      (struct sockaddr*)&from->sa, &from->salen);    } while (rv == -1 && (serrno = sock_errno()) == EINTR);    if (rv == -1 && serrno == SOCEWOULDBLOCK && sock->timeout != 0) {        apr_status_t arv = apr_wait_for_io_or_timeout(NULL, sock, 1);        if (arv != APR_SUCCESS) {            *len = 0;            return arv;        } else {            do {                rv = recvfrom(sock->socketdes, buf, *len, flags,                              (struct sockaddr*)&from->sa, &from->salen);                } while (rv == -1 && (serrno = sock_errno()) == EINTR);        }    }    if (rv == -1) {        (*len) = 0;        return APR_FROM_OS_ERROR(serrno);    }    (*len) = rv;    if (rv == 0 && sock->type == SOCK_STREAM)        return APR_EOF;    return APR_SUCCESS;}

intset_dscp(int fd, uint8_t dscp){    int val;    bool success;#ifdef _WIN32    /* XXX: Consider using QoS2 APIs for Windows to set dscp. */    return 0;#endif    if (dscp > 63) {        return EINVAL;    }    /* Note: this function is used for both of IPv4 and IPv6 sockets */    success = false;    val = dscp << 2;    if (setsockopt(fd, IPPROTO_IP, IP_TOS, &val, sizeof val)) {        if (sock_errno() != ENOPROTOOPT) {            return sock_errno();        }    } else {        success = true;    }    if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &val, sizeof val)) {        if (sock_errno() != ENOPROTOOPT) {            return sock_errno();        }    } else {        success = true;    }    if (!success) {        return ENOPROTOOPT;    }    return 0;}

APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock, char *buf,                                          apr_size_t *len){    apr_ssize_t rv;    int fds, err = 0;    do {        if (!sock->nonblock || (err == SOCEWOULDBLOCK && sock->timeout != 0)) {            fds = sock->socketdes;            rv = select(&fds, 1, 0, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);            if (rv != 1) {                *len = 0;                err = sock_errno();                if (rv == 0)                    return APR_TIMEUP;                if (err == SOCEINTR)                    continue;                return APR_FROM_OS_ERROR(err);            }        }        rv = recv(sock->socketdes, buf, (*len), 0);        err = rv < 0 ? sock_errno() : 0;    } while (err == SOCEINTR || (err == SOCEWOULDBLOCK && sock->timeout != 0));    if (err) {        *len = 0;        return APR_FROM_OS_ERROR(err);    }    (*len) = rv;    return rv == 0 ? APR_EOF : APR_SUCCESS;}

static apr_status_t socket_cleanup(void *sock){    apr_socket_t *thesocket = sock;    if (thesocket->socketdes < 0) {        return APR_EINVALSOCK;    }    if (soclose(thesocket->socketdes) == 0) {        thesocket->socketdes = -1;        return APR_SUCCESS;    }    else {        return APR_OS2_STATUS(sock_errno());    }}