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