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 */ 145int socket_init( void ); 146 147/* return the name of the current host */ 148char* host_name( void ); 149 150/* supported socket types */ 151typedef enum { 152 SOCKET_DGRAM = 0, 153 SOCKET_STREAM 154} SocketType; 155 156/* supported socket families */ 157typedef 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 */ 168typedef 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 */ 192void 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 198void 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 205void sock_address_init_unix( SockAddress* a, const char* path ); 206#endif 207 208/* Finalize a socket address, only needed for now for Unix addresses */ 209void sock_address_done( SockAddress* a ); 210 211int sock_address_equal( const SockAddress* a, const SockAddress* b ); 212 213/* return a static string describing the address */ 214const char* sock_address_to_string( const SockAddress* a ); 215 216static __inline__ 217SocketFamily 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 */ 223int 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 */ 226void 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 */ 229const char* sock_address_get_path( const SockAddress* a ); 230 231/* return the inet address, or -1 if it's not SOCKET_INET */ 232int sock_address_get_ip( const SockAddress* a ); 233 234/* bufprint a socket address into a human-readable string */ 235char* 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 */ 246int sock_address_init_resolve( SockAddress* a, 247 const char* hostname, 248 uint16_t port, 249 int preferIn6 ); 250 251int 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 */ 258enum { 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 */ 280SockAddress** 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 */ 303SockAddress** sock_address_list_create2(const char* host_and_port, 304 unsigned flags ); 305 306void sock_address_list_free( SockAddress** list ); 307 308/* create a new socket, return the socket number of -1 on failure */ 309int 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 */ 314int 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 320int 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 327int socket_create_unix( SocketType type ); 328#endif 329 330/* return the type of a given socket */ 331SocketType socket_get_type(int fd); 332 333/* set SO_REUSEADDR on Unix, SO_EXCLUSIVEADDR on Windows */ 334int socket_set_xreuseaddr(int fd); 335 336/* set socket in non-blocking mode */ 337int socket_set_nonblock(int fd); 338 339/* set socket in blocking mode */ 340int socket_set_blocking(int fd); 341 342/* disable the TCP Nagle algorithm for lower latency */ 343int socket_set_nodelay(int fd); 344 345/* send OOB data inline for this socket */ 346int socket_set_oobinline(int fd); 347 348/* force listening to IPv6 interfaces only */ 349int socket_set_ipv6only(int fd); 350 351/* retrieve last socket error code */ 352int socket_get_error(int fd); 353 354/* close an opened socket. Note that this is unlike the Unix 'close' because: 355 * - it will properly shutdown the socket in the background 356 * - it does not modify errno 357 */ 358void socket_close( int fd ); 359 360/* the following functions are equivalent to the BSD sockets ones 361 */ 362int socket_recv ( int fd, void* buf, int buflen ); 363int socket_recvfrom( int fd, void* buf, int buflen, SockAddress* from ); 364 365int socket_send ( int fd, const void* buf, int buflen ); 366int socket_send_oob( int fd, const void* buf, int buflen ); 367int socket_sendto( int fd, const void* buf, int buflen, const SockAddress* to ); 368 369int socket_connect( int fd, const SockAddress* address ); 370int socket_bind( int fd, const SockAddress* address ); 371int socket_get_address( int fd, SockAddress* address ); 372int socket_get_peer_address( int fd, SockAddress* address ); 373int socket_listen( int fd, int backlog ); 374int socket_accept( int fd, SockAddress* address ); 375 376/* returns the number of bytes that can be read from a socket */ 377int socket_can_read( int fd ); 378 379/* this call creates a pair of non-blocking sockets connected 380 * to each other. this is equivalent to calling the Unix function: 381 * socketpair(AF_LOCAL,SOCK_STREAM,0,&fds) 382 * 383 * on Windows, this will use a pair of TCP loopback sockets instead 384 * returns 0 on success, -1 on error. 385 */ 386int socket_pair(int *fd1, int *fd2); 387 388/* create a server socket listening on the host's loopback interface */ 389int socket_loopback_server( int port, SocketType type ); 390 391/* connect to a port on the host's loopback interface */ 392int socket_loopback_client( int port, SocketType type ); 393 394/* create a server socket listening to a Unix domain path */ 395#if HAVE_UNIX_SOCKETS 396int socket_unix_server( const char* name, SocketType type ); 397#endif 398 399/* create a Unix sockets and connects it to a Unix server */ 400#if HAVE_UNIX_SOCKETS 401int socket_unix_client( const char* name, SocketType type ); 402#endif 403 404/* create an IPv4 client socket and connect it to a given host */ 405int socket_network_client( const char* host, int port, SocketType type ); 406 407/* create an IPv4 socket and binds it to a given port of the host's interface */ 408int socket_anyaddr_server( int port, SocketType type ); 409 410/* accept a connection from the host's any interface, return the new socket 411 * descriptor or -1 */ 412int socket_accept_any( int server_fd ); 413 414 415int socket_mcast_inet_add_membership( int s, uint32_t ip ); 416int socket_mcast_inet_drop_membership( int s, uint32_t ip ); 417int socket_mcast_inet_set_loop( int s, int enabled ); 418int socket_mcast_inet_set_ttl( int s, int ttl ); 419 420#endif /* QEMU_SOCKET_H */ 421