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

static intmyAccept (int fd, struct sockaddr *addr, socklen_t *addrlen){  SOCKET fh = SOCKET_ERROR;  int new_fd;  /* Parameters to system calls are not guaranteed to generate a SIGSEGV     and for this reason we must touch them manually.  */  _gst_grey_oop_range (addr, *addrlen);#if defined SOCK_CLOEXEC && defined HAVE_ACCEPT4 && !defined __MSVCRT__  if (have_sock_cloexec >= 0)    {      fh = accept4 (FD_TO_SOCKET (fd), addr, addrlen, SOCK_CLOEXEC);      if (!check_have_sock_cloexec (fh, ENOSYS))	return -1;    }#endif  if (fh == SOCKET_ERROR)    {      fh = accept (FD_TO_SOCKET (fd), addr, addrlen);      socket_set_cloexec (fh);    }  new_fd = (fh == SOCKET_ERROR ? -1 : SOCKET_TO_FD (fh));  if (new_fd != SOCKET_ERROR)    _gst_register_socket (new_fd, false);  return new_fd;}

static int_gl_close_fd_maybe_socket (int fd){  SOCKET sock = FD_TO_SOCKET (fd);  WSANETWORKEVENTS ev;  ev.lNetworkEvents = 0xDEADBEEF;  WSAEnumNetworkEvents (sock, NULL, &ev);  if (ev.lNetworkEvents != 0xDEADBEEF)    {      /* FIXME: other applications, like squid, use an undocumented	 _free_osfhnd free function.  But this is not enough: The 'osfile'	 flags for fd also needs to be cleared, but it is hard to access it.	 Instead, here we just close twice the file descriptor.  */      if (closesocket (sock))	{	  set_winsock_errno ();	  return -1;	}      else	{	  /* This call frees the file descriptor and does a	     CloseHandle ((HANDLE) _get_osfhandle (fd)), which fails.  */	  _close (fd);	  return 0;	}    }  else    return _close (fd);}

static intioctl_fd_maybe_socket (const struct fd_hook *remaining_list,                       gl_ioctl_fn primary,                       int fd, int request, void *arg){  SOCKET sock;  WSANETWORKEVENTS ev;  /* Test whether fd refers to a socket.  */  sock = FD_TO_SOCKET (fd);  ev.lNetworkEvents = 0xDEADBEEF;  WSAEnumNetworkEvents (sock, NULL, &ev);  if (ev.lNetworkEvents != 0xDEADBEEF)    {      /* fd refers to a socket.  */      if (ioctlsocket (sock, request, arg) < 0)        {          set_winsock_errno ();          return -1;        }      else        return 0;    }  else    /* Some other type of file descriptor.  */    return execute_ioctl_hooks (remaining_list, primary, fd, request, arg);}

ssize_trpl_recvfrom (int fd, void *buf, size_t len, int flags, struct sockaddr *from,              socklen_t *fromlen){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int frombufsize = (from != NULL ? *fromlen : 0);      int r = recvfrom (sock, buf, len, flags, from, fromlen);      if (r < 0)        set_winsock_errno ();      /* Winsock recvfrom() only returns a valid 'from' when the socket is         connectionless.  POSIX gives a valid 'from' for all types of         sockets.  */      else if (from != NULL && *fromlen == frombufsize)        rpl_getpeername (fd, from, fromlen);      return r;    }}

intrpl_setsockopt (int fd, int level, int optname, const void *optval, socklen_t optlen){  SOCKET sock = FD_TO_SOCKET (fd);  int r;  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      if (level == SOL_SOCKET          && (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO))        {          const struct timeval *tv = optval;          int milliseconds = tv->tv_sec * 1000 + tv->tv_usec / 1000;          optval = &milliseconds;          r = setsockopt (sock, level, optname, optval, sizeof (int));        }      else        {          r = setsockopt (sock, level, optname, optval, optlen);        }      if (r < 0)        set_winsock_errno ();      return r;    }}

intrpl_connect (int fd, const struct sockaddr *sockaddr, socklen_t len){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = connect (sock, sockaddr, len);      if (r < 0)        {          /* EINPROGRESS is not returned by WinSock 2.0; for backwards             compatibility, connect(2) uses EWOULDBLOCK.  */          if (WSAGetLastError () == WSAEWOULDBLOCK)            WSASetLastError (WSAEINPROGRESS);          set_winsock_errno ();        }      return r;    }}

/* Same as connect, but forces the socket to be in non-blocking mode */static intmyConnect (int fd, struct sockaddr *sockaddr, int len){  SOCKET sock = FD_TO_SOCKET (fd);  int rc;#ifdef __MSVCRT__  unsigned long iMode = 1;  ioctlsocket (sock, FIONBIO, &iMode);#elif defined F_GETFL#ifndef O_NONBLOCK             #warning Non-blocking I/O could not be enabled#else  int oldflags = fcntl (sock, F_GETFL, NULL);  if (!(oldflags & O_NONBLOCK))    fcntl (sock, F_SETFL, oldflags | O_NONBLOCK);#endif#endif    fix_sockaddr (sockaddr);  rc = connect (sock, sockaddr, len);  if (rc == 0 || is_socket_error (EINPROGRESS) || is_socket_error (EWOULDBLOCK))    return 0;  else    return -1;}

boolssl_connect_wget (int fd, const char *hostname){  SSL *conn;  struct scwt_context scwt_ctx;  struct openssl_transport_context *ctx;  DEBUGP (("Initiating SSL handshake./n"));  assert (ssl_ctx != NULL);  conn = SSL_new (ssl_ctx);  if (!conn)    goto error;#if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)  /* If the SSL library was build with support for ServerNameIndication     then use it whenever we have a hostname.  If not, don't, ever. */  if (! is_valid_ip_address (hostname))    {      if (! SSL_set_tlsext_host_name (conn, hostname))        {          DEBUGP (("Failed to set TLS server-name indication."));          goto error;        }    }#endif#ifndef FD_TO_SOCKET# define FD_TO_SOCKET(X) (X)#endif  if (!SSL_set_fd (conn, FD_TO_SOCKET (fd)))    goto error;  SSL_set_connect_state (conn);  scwt_ctx.ssl = conn;  if (run_with_timeout(opt.read_timeout, ssl_connect_with_timeout_callback,                       &scwt_ctx)) {    DEBUGP (("SSL handshake timed out./n"));    goto timeout;  }  if (scwt_ctx.result <= 0 || conn->state != SSL_ST_OK)    goto error;  ctx = xnew0 (struct openssl_transport_context);  ctx->conn = conn;  /* Register FD with Wget's transport layer, i.e. arrange that our     functions are used for reading, writing, and polling.  */  fd_register_transport (fd, &openssl_transport, ctx);  DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx/n",           fd, PTR_FORMAT (conn)));  return true; error:  DEBUGP (("SSL handshake failed./n"));  print_errors (); timeout:  if (conn)    SSL_free (conn);  return false;}

static intmySendto (int fd, const char *buf, int len, int flags,	  struct sockaddr *to, int tolen){  fix_sockaddr (to);  return sendto (FD_TO_SOCKET (fd), buf, len, flags, to, tolen);}

ssize_t_gst_send (int fd,	   PTR buffer,	   size_t size,	   int flags){#ifdef HAVE_SOCKETS  ssize_t result;  int save_errno = errno;  for (;;)    {      result = send (FD_TO_SOCKET (fd), buffer, size, flags);      if (is_socket_error (EFAULT))        abort ();      if (is_socket_error (EINTR))	clear_socket_error ();      else	break;    }  if (errno == EINTR)    errno = save_errno;  return result;#else  errno = ENOSYS;  return -1;#endif}

static intmyListen (int fd, int backlog){  int r = listen (FD_TO_SOCKET (fd), backlog);  if (r != SOCKET_ERROR)    _gst_register_socket (fd, true);  return r;}

boolssl_connect_wget (int fd){  static const int cert_type_priority[] = {    GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0  };  struct wgnutls_transport_context *ctx;  gnutls_session session;  int err;  int allowed_protocols[4] = {0, 0, 0, 0};  gnutls_init (&session, GNUTLS_CLIENT);  gnutls_set_default_priority (session);  gnutls_certificate_type_set_priority (session, cert_type_priority);  gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, credentials);#ifndef FD_TO_SOCKET# define FD_TO_SOCKET(X) (X)#endif  gnutls_transport_set_ptr (session, (gnutls_transport_ptr) FD_TO_SOCKET (fd));  err = 0;  switch (opt.secure_protocol)    {    case secure_protocol_auto:      break;    case secure_protocol_sslv2:    case secure_protocol_sslv3:      allowed_protocols[0] = GNUTLS_SSL3;      err = gnutls_protocol_set_priority (session, allowed_protocols);      break;    case secure_protocol_tlsv1:      allowed_protocols[0] = GNUTLS_TLS1_0;      allowed_protocols[1] = GNUTLS_TLS1_1;      allowed_protocols[2] = GNUTLS_TLS1_2;      err = gnutls_protocol_set_priority (session, allowed_protocols);      break;    default:      abort ();    }  if (err < 0)    {      logprintf (LOG_NOTQUIET, "GnuTLS: %s/n", gnutls_strerror (err));      gnutls_deinit (session);      return false;    }  err = gnutls_handshake (session);  if (err < 0)    {      logprintf (LOG_NOTQUIET, "GnuTLS: %s/n", gnutls_strerror (err));      gnutls_deinit (session);      return false;    }  ctx = xnew0 (struct wgnutls_transport_context);  ctx->session = session;  fd_register_transport (fd, &wgnutls_transport, ctx);  return true;}

static intmyGetsockopt (int fd, int level, int optname, char *optval, socklen_t *optlen){  /* Parameters to system calls are not guaranteed to generate a SIGSEGV     and for this reason we must touch them manually.  */  _gst_grey_oop_range (optval, *optlen);  return getsockopt (FD_TO_SOCKET (fd), level, optname, optval, optlen);}

static intmyGetsockname (int fd, struct sockaddr *addr, socklen_t *addrlen){  /* Parameters to system calls are not guaranteed to generate a SIGSEGV     and for this reason we must touch them manually.  */  _gst_grey_oop_range (addr, *addrlen);  return getsockname (FD_TO_SOCKET (fd), addr, addrlen);}

intrpl_listen (int fd, int backlog){  SOCKET sock = FD_TO_SOCKET (fd);  int r = listen (sock, backlog);  if (r < 0)    set_winsock_errno ();  return r;}

ssize_trpl_send (int fd, const void *buf, size_t len, int flags){  SOCKET sock = FD_TO_SOCKET (fd);  int r = send (sock, buf, len, flags);  if (r < 0)    set_winsock_errno ();  return r;}

intrpl_getpeername (int fd, struct sockaddr *addr, socklen_t *addrlen){  SOCKET sock = FD_TO_SOCKET (fd);  int r = getpeername (sock, addr, addrlen);  if (r < 0)    set_winsock_errno ();  return r;}

intrpl_shutdown (int fd, int how){  SOCKET sock = FD_TO_SOCKET (fd);  int r = shutdown (sock, how);  if (r < 0)    set_winsock_errno ();  return r;}

intrpl_bind (int fd, struct sockaddr *sockaddr, int len){  SOCKET sock = FD_TO_SOCKET (fd);  int r = bind (sock, sockaddr, len);  if (r < 0)    set_winsock_errno ();  return r;}

intrpl_getsockopt (int fd, int level, int optname, void *optval, socklen_t *optlen){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r;      if (level == SOL_SOCKET          && (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO))        {          int milliseconds;          int milliseconds_len = sizeof (int);          struct timeval tv;          size_t n;          r = getsockopt (sock, level, optname, (char *) &milliseconds,                          &milliseconds_len);          tv.tv_sec = milliseconds / 1000;          tv.tv_usec = (milliseconds - 1000 * tv.tv_sec) * 1000;          n = sizeof (struct timeval);          if (n > *optlen)            n = *optlen;          memcpy (optval, &tv, n);          *optlen = n;        }      else        {          r = getsockopt (sock, level, optname, optval, optlen);        }      if (r < 0)        set_winsock_errno ();      return r;    }}

int VMPI_close(int fildes){    SOCKET sd = FD_TO_SOCKET(fildes);        if(  WIN32_is_socket( sd ) )    {        int result = closesocket( sd );        if( (result == SOCKET_ERROR) || (result == INVALID_SOCKET) )        {            errno = WIN32_winsock_to_errno();            return -1;        }        return result;    }    return _close( fildes );}

intrpl_shutdown (int fd, int how){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = shutdown (sock, how);      if (r < 0)        set_winsock_errno ();      return r;    }}

intrpl_bind (int fd, const struct sockaddr *sockaddr, socklen_t len){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = bind (sock, sockaddr, len);      if (r < 0)        set_winsock_errno ();      return r;    }}

intrpl_listen (int fd, int backlog){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = listen (sock, backlog);      if (r < 0)        set_winsock_errno ();      return r;    }}

intrpl_getpeername (int fd, struct sockaddr *addr, socklen_t *addrlen){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = getpeername (sock, addr, addrlen);      if (r < 0)        set_winsock_errno ();      return r;    }}

intrpl_ioctl (int fd, int req, ...){  void *buf;  va_list args;  SOCKET sock;  int r;  va_start (args, req);  buf = va_arg (args, void *);  va_end (args);  sock = FD_TO_SOCKET (fd);  r = ioctlsocket (sock, req, buf);  if (r < 0)    set_winsock_errno ();  return r;}

ssize_trpl_send (int fd, const void *buf, size_t len, int flags){  SOCKET sock = FD_TO_SOCKET (fd);  if (sock == INVALID_SOCKET)    {      errno = EBADF;      return -1;    }  else    {      int r = send (sock, buf, len, flags);      if (r < 0)        set_winsock_errno ();      return r;    }}

int VMPI_shutdown(int socket, int how){    int result;    if( WIN32_SocketStart(2,2) == 0 )    {        result = shutdown( FD_TO_SOCKET(socket), how );    }    else    {        return -1;    }    if( (result == SOCKET_ERROR) || (result == INVALID_SOCKET) )    {        errno = WIN32_winsock_to_errno();        return -1;    }    return result;}

int VMPI_send(int socket, const void *buffer, size_t length, int flags){    int result;    if( WIN32_SocketStart(2,2) == 0 )    {        result = send( FD_TO_SOCKET(socket), (const char *)buffer, (int)length, flags );    }    else    {        return -1;    }    if( (result == SOCKET_ERROR) || (result == INVALID_SOCKET) )    {        errno = WIN32_winsock_to_errno();        return -1;    }    return result;}

int VMPI_sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len){    int result;    if( WIN32_SocketStart(2,2) == 0 )    {        result = sendto( FD_TO_SOCKET(socket), (const char *)message, (int)length, flags, dest_addr, dest_len );    }    else    {        return -1;    }    if( (result == SOCKET_ERROR) || (result == INVALID_SOCKET) )    {        errno = WIN32_winsock_to_errno();        return -1;    }    return result;}