folly/portability/Sockets.h

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #pragma once
  18
  19 #ifndef _WIN32
  20 #include <netdb.h>
  21 #include <poll.h>
  22
  23 #include <arpa/inet.h>
  24 #include <netinet/in.h>
  25 #include <netinet/tcp.h>
  26 #include <sys/socket.h>
  27 #include <sys/un.h>
  28 #else
  29 #include <folly/portability/IOVec.h>
  30 #include <folly/portability/SysTypes.h>
  31 #include <folly/portability/Windows.h>
  32
  33 #include <WS2tcpip.h>
  34
  35 using nfds_t = int;
  36 using sa_family_t = ADDRESS_FAMILY;
  37
  38 // We don't actually support either of these flags
  39 // currently.
  40 #define MSG_DONTWAIT 0
  41 #define MSG_EOR 0
  42 struct msghdr {
  43   void* msg_name;
  44   socklen_t msg_namelen;
  45   struct iovec* msg_iov;
  46   size_t msg_iovlen;
  47   void* msg_control;
  48   size_t msg_controllen;
  49   int msg_flags;
  50 };
  51
  52 struct sockaddr_un {
  53   sa_family_t sun_family;
  54   char sun_path[108];
  55 };
  56
  57 #define SHUT_RD SD_RECEIVE
  58 #define SHUT_WR SD_SEND
  59 #define SHUT_RDWR SD_BOTH
  60
  61 // These are the same, but PF_LOCAL
  62 // isn't defined by WinSock.
  63 #define PF_LOCAL PF_UNIX
  64 #define SO_REUSEPORT SO_REUSEADDR
  65
  66 // Someone thought it would be a good idea
  67 // to define a field via a macro...
  68 #undef s_host
  69 #endif
  70
  71 namespace folly {
  72 namespace portability {
  73 namespace sockets {
  74 #ifndef _WIN32
  75 using ::accept;
  76 using ::bind;
  77 using ::connect;
  78 using ::getpeername;
  79 using ::getsockname;
  80 using ::getsockopt;
  81 using ::inet_ntop;
  82 using ::listen;
  83 using ::poll;
  84 using ::recv;
  85 using ::recvfrom;
  86 using ::send;
  87 using ::sendto;
  88 using ::sendmsg;
  89 using ::setsockopt;
  90 using ::shutdown;
  91 using ::socket;
  92 #else
  93 // Some Windows specific helper functions.
  94 bool is_fh_socket(int fh);
  95 SOCKET fd_to_socket(int fd);
  96 int socket_to_fd(SOCKET s);
  97
  98 // These aren't additional overloads, but rather other functions that
  99 // are referenced that we need to wrap, or, in the case of inet_aton,
 100 // implement.
 101 int accept(int s, struct sockaddr* addr, socklen_t* addrlen);
 102 int inet_aton(const char* cp, struct in_addr* inp);
 103 int socketpair(int domain, int type, int protocol, int sv[2]);
 104
 105 // Unless you have a case where you would normally have
 106 // to reference the function as being explicitly in the
 107 // global scope, then you shouldn't be calling these directly.
 108 int bind(int s, const struct sockaddr* name, socklen_t namelen);
 109 int connect(int s, const struct sockaddr* name, socklen_t namelen);
 110 int getpeername(int s, struct sockaddr* name, socklen_t* namelen);
 111 int getsockname(int s, struct sockaddr* name, socklen_t* namelen);
 112 int getsockopt(int s, int level, int optname, void* optval, socklen_t* optlen);
 113 const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);
 114 int listen(int s, int backlog);
 115 int poll(struct pollfd fds[], nfds_t nfds, int timeout);
 116 ssize_t recv(int s, void* buf, size_t len, int flags);
 117 ssize_t recvfrom(
 118     int s,
 119     void* buf,
 120     size_t len,
 121     int flags,
 122     struct sockaddr* from,
 123     socklen_t* fromlen);
 124 ssize_t send(int s, const void* buf, size_t len, int flags);
 125 ssize_t sendto(
 126     int s,
 127     const void* buf,
 128     size_t len,
 129     int flags,
 130     const sockaddr* to,
 131     socklen_t tolen);
 132 ssize_t sendmsg(int socket, const struct msghdr* message, int flags);
 133 int setsockopt(
 134     int s,
 135     int level,
 136     int optname,
 137     const void* optval,
 138     socklen_t optlen);
 139 int shutdown(int s, int how);
 140
 141 // This is the only function that _must_ be referenced via the namespace
 142 // because there is no difference in parameter types to overload
 143 // on.
 144 int socket(int af, int type, int protocol);
 145
 146 // Windows needs a few extra overloads of some of the functions in order to
 147 // resolve to our portability functions rather than the SOCKET accepting
 148 // ones.
 149 int getsockopt(int s, int level, int optname, char* optval, socklen_t* optlen);
 150 ssize_t recv(int s, char* buf, int len, int flags);
 151 ssize_t recv(int s, void* buf, int len, int flags);
 152 ssize_t recvfrom(
 153     int s,
 154     char* buf,
 155     int len,
 156     int flags,
 157     struct sockaddr* from,
 158     socklen_t* fromlen);
 159 ssize_t recvfrom(
 160     int s,
 161     void* buf,
 162     int len,
 163     int flags,
 164     struct sockaddr* from,
 165     socklen_t* fromlen);
 166 ssize_t recvmsg(int s, struct msghdr* message, int fl);
 167 ssize_t send(int s, const char* buf, int len, int flags);
 168 ssize_t send(int s, const void* buf, int len, int flags);
 169 ssize_t sendto(
 170     int s,
 171     const char* buf,
 172     int len,
 173     int flags,
 174     const sockaddr* to,
 175     socklen_t tolen);
 176 ssize_t sendto(
 177     int s,
 178     const void* buf,
 179     int len,
 180     int flags,
 181     const sockaddr* to,
 182     socklen_t tolen);
 183 int setsockopt(
 184     int s,
 185     int level,
 186     int optname,
 187     const char* optval,
 188     socklen_t optlen);
 189 #endif
 190 }
 191 }
 192 }
 193
 194 #ifdef _WIN32
 195 // Add our helpers to the overload set.
 196 /* using override */ using namespace folly::portability::sockets;
 197 #endif