1 /*
2 * Copyright (C) 2011 The Android Open Source Project
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 /* headers to use the BSD sockets */
17 #ifndef ANDROID_SOCKET_H
18 #define ANDROID_SOCKET_H
19
20 #include <stddef.h>
21 #include <stdint.h>
22 #include <errno.h>
23
24 #ifdef __cplusplus
25 extern "C" {
26 #endif
27
28 /* we're going to hide the implementation details of sockets behind
29 * a simple wrapper interface declared here.
30 *
31 * all socket operations set the global 'errno' variable on error.
32 * this is unlike Winsock which instead modifies another internal
33 * variable accessed through WSAGetLastError() and WSASetLastError()
34 */
35
36 /* the wrapper will convert any Winsock error message into an errno
37 * code for you. There are however a few standard Unix error codes
38 * that are not defined by the MS C library headers, so we add them
39 * here. We use the official Winsock error codes, which are documented
40 * even though we don't want to include the Winsock headers
41 */
42 #ifdef _WIN32
43 # ifndef EINTR
44 # define EINTR 10004
45 # endif
46 # ifndef EAGAIN
47 # define EAGAIN 10035
48 # endif
49 # ifndef EWOULDBLOCK
50 # define EWOULDBLOCK EAGAIN
51 # endif
52 # ifndef EINPROGRESS
53 # define EINPROGRESS 10036
54 # endif
55 # ifndef EALREADY
56 # define EALREADY 10037
57 # endif
58 # ifndef EDESTADDRREQ
59 # define EDESTADDRREQ 10039
60 # endif
61 # ifndef EMSGSIZE
62 # define EMSGSIZE 10040
63 # endif
64 # ifndef EPROTOTYPE
65 # define EPROTOTYPE 10041
66 # endif
67 # ifndef ENOPROTOOPT
68 # define ENOPROTOOPT 10042
69 # endif
70 # ifndef EAFNOSUPPORT
71 # define EAFNOSUPPORT 10047
72 # endif
73 # ifndef EADDRINUSE
74 # define EADDRINUSE 10048
75 # endif
76 # ifndef EADDRNOTAVAIL
77 # define EADDRNOTAVAIL 10049
78 # endif
79 # ifndef ENETDOWN
80 # define ENETDOWN 10050
81 # endif
82 # ifndef ENETUNREACH
83 # define ENETUNREACH 10051
84 # endif
85 # ifndef ENETRESET
86 # define ENETRESET 10052
87 # endif
88 # ifndef ECONNABORTED
89 # define ECONNABORTED 10053
90 # endif
91 # ifndef ECONNRESET
92 # define ECONNRESET 10054
93 # endif
94 # ifndef ENOBUFS
95 # define ENOBUFS 10055
96 # endif
97 # ifndef EISCONN
98 # define EISCONN 10056
99 # endif
100 # ifndef ENOTCONN
101 # define ENOTCONN 10057
102 # endif
103 # ifndef ESHUTDOWN
104 # define ESHUTDOWN 10058
105 # endif
106 # ifndef ETOOMANYREFS
107 # define ETOOMANYREFS 10059
108 # endif
109 # ifndef ETIMEDOUT
110 # define ETIMEDOUT 10060
111 # endif
112 # ifndef ECONNREFUSED
113 # define ECONNREFUSED 10061
114 # endif
115 # ifndef ELOOP
116 # define ELOOP 10062
117 # endif
118 # ifndef EHOSTDOWN
119 # define EHOSTDOWN 10064
120 # endif
121 # ifndef EHOSTUNREACH
122 # define EHOSTUNREACH 10065
123 # endif
124 #endif /* _WIN32 */
125
126 /* Define 'errno_str' as a handy macro to return the string
127 * corresponding to a given errno code. On Unix, this is
128 * equivalent to strerror(errno), but on Windows, this will
129 * take care of Winsock-originated errors as well.
130 */
131 #ifdef _WIN32
132 extern const char* _errno_str(void);
133 # define errno_str _errno_str()
134 #else
135 # define errno_str strerror(errno)
136 #endif
137
138 /* always enable IPv6 sockets for now.
139 * the QEMU internal router is not capable of
140 * supporting them, but we plan to replace it
141 * with something better in the future.
142 */
143 #define HAVE_IN6_SOCKETS 1
144
145 /* Unix sockets are not available on Win32 */
146 #ifndef _WIN32
147 # define HAVE_UNIX_SOCKETS 1
148 #endif
149
150 /* initialize the socket sub-system. this must be called before
151 * using any of the declarations below.
152 */
153 int socket_init( void );
154
155 /* return the name of the current host */
156 char* host_name( void );
157
158 /* supported socket types */
159 typedef enum {
160 SOCKET_DGRAM = 0,
161 SOCKET_STREAM
162 } SocketType;
163
164 /* supported socket families */
165 typedef enum {
166 SOCKET_UNSPEC,
167 SOCKET_INET,
168 SOCKET_IN6,
169 SOCKET_UNIX
170 } SocketFamily;
171
172 /* Generic socket address structure. Note that for Unix
173 * sockets, the path is stored in a heap-allocated block,
174 * unless the 'owner' field is cleared. If this is the case,
175 */
176 typedef struct {
177 SocketFamily family;
178 union {
179 struct {
180 uint16_t port;
181 uint32_t address;
182 } inet;
183 struct {
184 uint16_t port;
185 uint8_t address[16];
186 } in6;
187 struct {
188 int owner;
189 const char* path;
190 } _unix;
191 } u;
192 } SockAddress;
193
194 #define SOCK_ADDRESS_INET_ANY 0x00000000
195 #define SOCK_ADDRESS_INET_LOOPBACK 0x7f000001
196
197 /* initialize a new IPv4 socket address, the IP address and port are
198 * in host endianess.
199 */
200 void sock_address_init_inet( SockAddress* a, uint32_t ip, uint16_t port );
201
202 /* Initialize an IPv6 socket address, the address is in network order
203 * and the port in host endianess.
204 */
205 #if HAVE_IN6_SOCKETS
206 void sock_address_init_in6 ( SockAddress* a, const uint8_t* ip6[16], uint16_t port );
207 #endif
208
209 /* Intialize a Unix socket address, this will copy the 'path' string into the
210 * heap. You need to call sock_address_done() to release the copy
211 */
212 #if HAVE_UNIX_SOCKETS
213 void sock_address_init_unix( SockAddress* a, const char* path );
214 #endif
215
216 /* Finalize a socket address, only needed for now for Unix addresses */
217 void sock_address_done( SockAddress* a );
218
219 int sock_address_equal( const SockAddress* a, const SockAddress* b );
220
221 /* return a static string describing the address */
222 const char* sock_address_to_string( const SockAddress* a );
223
224 static __inline__
sock_address_get_family(const SockAddress * a)225 SocketFamily sock_address_get_family( const SockAddress* a )
226 {
227 return a->family;
228 }
229
230 /* return the port number of a given socket address, or -1 if it's a Unix one */
231 int sock_address_get_port( const SockAddress* a );
232
233 /* set the port number of a given socket address, don't do anything for Unix ones */
234 void sock_address_set_port( SockAddress* a, uint16_t port );
235
236 /* return the path of a given Unix socket, returns NULL for non-Unix ones */
237 const char* sock_address_get_path( const SockAddress* a );
238
239 /* return the inet address, or -1 if it's not SOCKET_INET */
240 int sock_address_get_ip( const SockAddress* a );
241
242 /* bufprint a socket address into a human-readable string */
243 char* bufprint_sock_address( char* p, char* end, const SockAddress* a );
244
245 /* resolve a hostname or decimal IPv4/IPv6 address into a socket address.
246 * returns 0 on success, or -1 on failure. Note that the values or errno
247 * set by this function are the following:
248 *
249 * EINVAL : invalid argument
250 * EHOSTDOWN : could not reach DNS server
251 * ENOENT : no host with this name, or host doesn't have any IP address
252 * ENOMEM : not enough memory to perform request
253 */
254 int sock_address_init_resolve( SockAddress* a,
255 const char* hostname,
256 uint16_t port,
257 int preferIn6 );
258
259 int sock_address_get_numeric_info( SockAddress* a,
260 char* host,
261 size_t hostlen,
262 char* serv,
263 size_t servlen );
264
265 /* Support for listing all socket addresses of a given host */
266 enum {
267 SOCKET_LIST_PASSIVE = (1 << 0),
268 SOCKET_LIST_FORCE_INET = (1 << 1),
269 SOCKET_LIST_FORCE_IN6 = (1 << 2),
270 SOCKET_LIST_DGRAM = (1 << 3),
271 };
272
273 /* resolve a host and service/port name into a list of SockAddress objects.
274 * returns a NULL-terminated array of SockAddress pointers on success,
275 * or NULL in case of failure, with the value of errno set to one of the
276 * following:
277 *
278 * EINVAL : invalid argument
279 * EHOSTDOWN : could not reach DNS server
280 * ENOENT : no host with this name, or host doesn't have IP address
281 * ENOMEM : not enough memory to perform request
282 *
283 * other system-level errors can also be set depending on the host sockets
284 * implementation.
285 *
286 * This function loops on EINTR so the caller shouldn't have to check for it.
287 */
288 SockAddress** sock_address_list_create( const char* hostname,
289 const char* port,
290 unsigned flags );
291
292 /* resolve a string containing host and port name into a list of SockAddress
293 * objects. Parameter host_and_port should be in format [host:]port, where
294 * 'host' addresses the machine and must be resolvable into an IP address, and
295 * 'port' is a decimal numeric value for the port. 'host' is optional, and if
296 * ommited, localhost will be used.
297 * returns a NULL-terminated array of SockAddress pointers on success,
298 * or NULL in case of failure, with the value of errno set to one of the
299 * following:
300 *
301 * EINVAL : invalid argument
302 * EHOSTDOWN : could not reach DNS server
303 * ENOENT : no host with this name, or host doesn't have IP address
304 * ENOMEM : not enough memory to perform request
305 *
306 * other system-level errors can also be set depending on the host sockets
307 * implementation.
308 *
309 * This function loops on EINTR so the caller shouldn't have to check for it.
310 */
311 SockAddress** sock_address_list_create2(const char* host_and_port,
312 unsigned flags );
313
314 void sock_address_list_free( SockAddress** list );
315
316 /* create a new socket, return the socket number of -1 on failure */
317 int socket_create( SocketFamily family, SocketType type );
318
319 /* create a new socket intended for IPv4 communication. returns the socket number,
320 * or -1 on failure.
321 */
322 int socket_create_inet( SocketType type );
323
324 /* create a new socket intended for IPv6 communication. returns the socket number,
325 * or -1 on failure.
326 */
327 #if HAVE_IN6_SOCKETS
328 int socket_create_in6 ( SocketType type );
329 #endif
330
331 /* create a unix/local domain socket. returns the socket number,
332 * or -1 on failure.
333 */
334 #if HAVE_UNIX_SOCKETS
335 int socket_create_unix( SocketType type );
336 #endif
337
338 /* return the type of a given socket */
339 SocketType socket_get_type(int fd);
340
341 /* set SO_REUSEADDR on Unix, SO_EXCLUSIVEADDR on Windows */
342 int socket_set_xreuseaddr(int fd);
343
344 /* set socket in non-blocking mode */
345 int socket_set_nonblock(int fd);
346
347 /* set socket in blocking mode */
348 int socket_set_blocking(int fd);
349
350 /* disable the TCP Nagle algorithm for lower latency */
351 int socket_set_nodelay(int fd);
352
353 /* send OOB data inline for this socket */
354 int socket_set_oobinline(int fd);
355
356 /* force listening to IPv6 interfaces only */
357 int socket_set_ipv6only(int fd);
358
359 /* retrieve last socket error code */
360 int socket_get_error(int fd);
361
362 /* close an opened socket. Note that this is unlike the Unix 'close' because:
363 * - it will properly shutdown the socket in the background
364 * - it does not modify errno
365 */
366 void socket_close( int fd );
367
368 /* the following functions are equivalent to the BSD sockets ones
369 */
370 int socket_recv ( int fd, void* buf, int buflen );
371 int socket_recvfrom( int fd, void* buf, int buflen, SockAddress* from );
372
373 int socket_send ( int fd, const void* buf, int buflen );
374 int socket_send_oob( int fd, const void* buf, int buflen );
375 int socket_sendto( int fd, const void* buf, int buflen, const SockAddress* to );
376
377 int socket_connect( int fd, const SockAddress* address );
378 int socket_bind( int fd, const SockAddress* address );
379 int socket_get_address( int fd, SockAddress* address );
380 int socket_get_peer_address( int fd, SockAddress* address );
381 int socket_listen( int fd, int backlog );
382 int socket_accept( int fd, SockAddress* address );
383
384 /* returns the number of bytes that can be read from a socket */
385 int socket_can_read( int fd );
386
387 /* this call creates a pair of non-blocking sockets connected
388 * to each other. this is equivalent to calling the Unix function:
389 * socketpair(AF_LOCAL,SOCK_STREAM,0,&fds)
390 *
391 * on Windows, this will use a pair of TCP loopback sockets instead
392 * returns 0 on success, -1 on error.
393 */
394 int socket_pair(int *fd1, int *fd2);
395
396 /* create a server socket listening on the host's loopback interface */
397 int socket_loopback_server( int port, SocketType type );
398
399 /* connect to a port on the host's loopback interface */
400 int socket_loopback_client( int port, SocketType type );
401
402 /* create a server socket listening to a Unix domain path */
403 #if HAVE_UNIX_SOCKETS
404 int socket_unix_server( const char* name, SocketType type );
405 #endif
406
407 /* create a Unix sockets and connects it to a Unix server */
408 #if HAVE_UNIX_SOCKETS
409 int socket_unix_client( const char* name, SocketType type );
410 #endif
411
412 /* create an IPv4 client socket and connect it to a given host */
413 int socket_network_client( const char* host, int port, SocketType type );
414
415 /* create an IPv4 socket and binds it to a given port of the host's interface */
416 int socket_anyaddr_server( int port, SocketType type );
417
418 /* accept a connection from the host's any interface, return the new socket
419 * descriptor or -1 */
420 int socket_accept_any( int server_fd );
421
422
423 int socket_mcast_inet_add_membership( int s, uint32_t ip );
424 int socket_mcast_inet_drop_membership( int s, uint32_t ip );
425 int socket_mcast_inet_set_loop( int s, int enabled );
426 int socket_mcast_inet_set_ttl( int s, int ttl );
427
428 #ifdef __cplusplus
429 }
430 #endif
431
432 #endif /* ANDROID_SOCKET_H */
433