folly/portability/Sockets.h

   1 /*
   2  * Copyright 2017 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> // @manual
  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 0x1000
  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 AF_LOCAL PF_UNIX
  64 #define PF_LOCAL PF_UNIX
  65
  66 // This isn't defined by Windows, and we need to
  67 // distinguish it from SO_REUSEADDR
  68 #define SO_REUSEPORT 0x7001
  69
  70 // Someone thought it would be a good idea
  71 // to define a field via a macro...
  72 #undef s_host
  73 #endif
  74
  75 namespace folly {
  76 namespace portability {
  77 namespace sockets {
  78 #ifndef _WIN32
  79 using ::accept;
  80 using ::bind;
  81 using ::connect;
  82 using ::getpeername;
  83 using ::getsockname;
  84 using ::getsockopt;
  85 using ::inet_ntop;
  86 using ::listen;
  87 using ::poll;
  88 using ::recv;
  89 using ::recvfrom;
  90 using ::send;
  91 using ::sendto;
  92 using ::sendmsg;
  93 using ::setsockopt;
  94 using ::shutdown;
  95 using ::socket;
  96 #else
  97 // Some Windows specific helper functions.
  98 bool is_fh_socket(int fh);
  99 SOCKET fd_to_socket(int fd);
 100 int socket_to_fd(SOCKET s);
 101 int translate_wsa_error(int wsaErr);
 102
 103 // These aren't additional overloads, but rather other functions that
 104 // are referenced that we need to wrap, or, in the case of inet_aton,
 105 // implement.
 106 int accept(int s, struct sockaddr* addr, socklen_t* addrlen);
 107 int inet_aton(const char* cp, struct in_addr* inp);
 108 int socketpair(int domain, int type, int protocol, int sv[2]);
 109
 110 // Unless you have a case where you would normally have
 111 // to reference the function as being explicitly in the
 112 // global scope, then you shouldn't be calling these directly.
 113 int bind(int s, const struct sockaddr* name, socklen_t namelen);
 114 int connect(int s, const struct sockaddr* name, socklen_t namelen);
 115 int getpeername(int s, struct sockaddr* name, socklen_t* namelen);
 116 int getsockname(int s, struct sockaddr* name, socklen_t* namelen);
 117 int getsockopt(int s, int level, int optname, void* optval, socklen_t* optlen);
 118 const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);
 119 int listen(int s, int backlog);
 120 int poll(struct pollfd fds[], nfds_t nfds, int timeout);
 121 ssize_t recv(int s, void* buf, size_t len, int flags);
 122 ssize_t recvfrom(
 123     int s,
 124     void* buf,
 125     size_t len,
 126     int flags,
 127     struct sockaddr* from,
 128     socklen_t* fromlen);
 129 ssize_t send(int s, const void* buf, size_t len, int flags);
 130 ssize_t sendto(
 131     int s,
 132     const void* buf,
 133     size_t len,
 134     int flags,
 135     const sockaddr* to,
 136     socklen_t tolen);
 137 ssize_t sendmsg(int socket, const struct msghdr* message, int flags);
 138 int setsockopt(
 139     int s,
 140     int level,
 141     int optname,
 142     const void* optval,
 143     socklen_t optlen);
 144 int shutdown(int s, int how);
 145
 146 // This is the only function that _must_ be referenced via the namespace
 147 // because there is no difference in parameter types to overload
 148 // on.
 149 int socket(int af, int type, int protocol);
 150
 151 // Windows needs a few extra overloads of some of the functions in order to
 152 // resolve to our portability functions rather than the SOCKET accepting
 153 // ones.
 154 int getsockopt(int s, int level, int optname, char* optval, socklen_t* optlen);
 155 ssize_t recv(int s, char* buf, int len, int flags);
 156 ssize_t recv(int s, void* buf, int len, int flags);
 157 ssize_t recvfrom(
 158     int s,
 159     char* buf,
 160     int len,
 161     int flags,
 162     struct sockaddr* from,
 163     socklen_t* fromlen);
 164 ssize_t recvfrom(
 165     int s,
 166     void* buf,
 167     int len,
 168     int flags,
 169     struct sockaddr* from,
 170     socklen_t* fromlen);
 171 ssize_t recvmsg(int s, struct msghdr* message, int fl);
 172 ssize_t send(int s, const char* buf, int len, int flags);
 173 ssize_t send(int s, const void* buf, int len, int flags);
 174 ssize_t sendto(
 175     int s,
 176     const char* buf,
 177     int len,
 178     int flags,
 179     const sockaddr* to,
 180     socklen_t tolen);
 181 ssize_t sendto(
 182     int s,
 183     const void* buf,
 184     int len,
 185     int flags,
 186     const sockaddr* to,
 187     socklen_t tolen);
 188 int setsockopt(
 189     int s,
 190     int level,
 191     int optname,
 192     const char* optval,
 193     socklen_t optlen);
 194 #endif
 195 }
 196 }
 197 }
 198
 199 #ifdef _WIN32
 200 // Add our helpers to the overload set.
 201 /* using override */ using namespace folly::portability::sockets;
 202 #endif