4 This file is part of polypaudio.
6 polypaudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 polypaudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with polypaudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 /* #undef HAVE_LIBASYNCNS */
35 #ifdef HAVE_SYS_SOCKET_H
36 #include <sys/socket.h>
41 #ifdef HAVE_ARPA_INET_H
42 #include <arpa/inet.h>
44 #ifdef HAVE_NETINET_IN_H
45 #include <netinet/in.h>
51 #ifdef HAVE_LIBASYNCNS
57 #include <polyp/xmalloc.h>
59 #include <polypcore/socket-util.h>
60 #include <polypcore/util.h>
61 #include <polypcore/log.h>
62 #include <polypcore/parseaddr.h>
64 #include "socket-client.h"
66 #define CONNECT_TIMEOUT 5
68 struct pa_socket_client {
70 pa_mainloop_api *mainloop;
72 pa_io_event *io_event;
73 pa_time_event *timeout_event;
74 pa_defer_event *defer_event;
75 void (*callback)(pa_socket_client*c, pa_iochannel *io, void *userdata);
78 #ifdef HAVE_LIBASYNCNS
80 asyncns_query_t * asyncns_query;
81 pa_io_event *asyncns_io_event;
85 static pa_socket_client*pa_socket_client_new(pa_mainloop_api *m) {
89 c = pa_xmalloc(sizeof(pa_socket_client));
94 c->defer_event = NULL;
95 c->timeout_event = NULL;
100 #ifdef HAVE_LIBASYNCNS
102 c->asyncns_io_event = NULL;
103 c->asyncns_query = NULL;
109 static void free_events(pa_socket_client *c) {
113 c->mainloop->io_free(c->io_event);
117 if (c->defer_event) {
118 c->mainloop->defer_free(c->defer_event);
119 c->defer_event = NULL;
122 if (c->timeout_event) {
123 c->mainloop->time_free(c->timeout_event);
124 c->timeout_event = NULL;
128 static void do_call(pa_socket_client *c) {
129 pa_iochannel *io = NULL;
132 assert(c && c->callback);
134 pa_socket_client_ref(c);
139 lerror = sizeof(error);
140 if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void*)&error, &lerror) < 0) {
141 pa_log(__FILE__": getsockopt(): %s", strerror(errno));
145 if (lerror != sizeof(error)) {
146 pa_log(__FILE__": getsockopt() returned invalid size.");
151 pa_log_debug(__FILE__": connect(): %s", strerror(error));
156 io = pa_iochannel_new(c->mainloop, c->fd, c->fd);
160 if (!io && c->fd >= 0)
167 c->callback(c, io, c->userdata);
169 pa_socket_client_unref(c);
172 static void connect_fixed_cb(pa_mainloop_api *m, pa_defer_event *e, void *userdata) {
173 pa_socket_client *c = userdata;
174 assert(m && c && c->defer_event == e);
178 static void connect_io_cb(pa_mainloop_api*m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags_t f, void *userdata) {
179 pa_socket_client *c = userdata;
180 assert(m && c && c->io_event == e && fd >= 0);
184 static int do_connect(pa_socket_client *c, const struct sockaddr *sa, socklen_t len) {
186 assert(c && sa && len);
188 pa_make_nonblock_fd(c->fd);
190 if ((r = connect(c->fd, sa, len)) < 0) {
192 if (WSAGetLastError() != EWOULDBLOCK) {
193 pa_log_debug(__FILE__": connect(): %d", WSAGetLastError());
195 if (errno != EINPROGRESS) {
196 pa_log_debug(__FILE__": connect(): %s (%d)", strerror(errno), errno);
201 c->io_event = c->mainloop->io_new(c->mainloop, c->fd, PA_IO_EVENT_OUTPUT, connect_io_cb, c);
204 c->defer_event = c->mainloop->defer_new(c->mainloop, connect_fixed_cb, c);
205 assert(c->defer_event);
211 pa_socket_client* pa_socket_client_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port) {
212 struct sockaddr_in sa;
213 assert(m && port > 0);
215 memset(&sa, 0, sizeof(sa));
216 sa.sin_family = AF_INET;
217 sa.sin_port = htons(port);
218 sa.sin_addr.s_addr = htonl(address);
220 return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
225 pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename) {
226 struct sockaddr_un sa;
227 assert(m && filename);
229 memset(&sa, 0, sizeof(sa));
230 sa.sun_family = AF_UNIX;
231 strncpy(sa.sun_path, filename, sizeof(sa.sun_path)-1);
232 sa.sun_path[sizeof(sa.sun_path) - 1] = 0;
234 return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
237 #else /* HAVE_SYS_UN_H */
239 pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename) {
243 #endif /* HAVE_SYS_UN_H */
245 static int sockaddr_prepare(pa_socket_client *c, const struct sockaddr *sa, size_t salen) {
250 switch (sa->sa_family) {
256 c->local = ((const struct sockaddr_in*) sa)->sin_addr.s_addr == INADDR_LOOPBACK;
260 c->local = memcmp(&((const struct sockaddr_in6*) sa)->sin6_addr, &in6addr_loopback, sizeof(struct in6_addr)) == 0;
267 if ((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0) {
268 pa_log(__FILE__": socket(): %s", strerror(errno));
272 pa_fd_set_cloexec(c->fd, 1);
273 if (sa->sa_family == AF_INET || sa->sa_family == AF_INET6)
274 pa_socket_tcp_low_delay(c->fd);
276 pa_socket_low_delay(c->fd);
278 if (do_connect(c, sa, salen) < 0)
284 pa_socket_client* pa_socket_client_new_sockaddr(pa_mainloop_api *m, const struct sockaddr *sa, size_t salen) {
287 c = pa_socket_client_new(m);
290 if (sockaddr_prepare(c, sa, salen) < 0)
296 pa_socket_client_unref(c);
301 static void socket_client_free(pa_socket_client *c) {
302 assert(c && c->mainloop);
310 #ifdef HAVE_LIBASYNCNS
311 if (c->asyncns_query)
312 asyncns_cancel(c->asyncns, c->asyncns_query);
314 asyncns_free(c->asyncns);
315 if (c->asyncns_io_event)
316 c->mainloop->io_free(c->asyncns_io_event);
322 void pa_socket_client_unref(pa_socket_client *c) {
323 assert(c && c->ref >= 1);
326 socket_client_free(c);
329 pa_socket_client* pa_socket_client_ref(pa_socket_client *c) {
330 assert(c && c->ref >= 1);
335 void pa_socket_client_set_callback(pa_socket_client *c, void (*on_connection)(pa_socket_client *c, pa_iochannel*io, void *userdata), void *userdata) {
337 c->callback = on_connection;
338 c->userdata = userdata;
341 pa_socket_client* pa_socket_client_new_ipv6(pa_mainloop_api *m, uint8_t address[16], uint16_t port) {
342 struct sockaddr_in6 sa;
344 memset(&sa, 0, sizeof(sa));
345 sa.sin6_family = AF_INET6;
346 sa.sin6_port = htons(port);
347 memcpy(&sa.sin6_addr, address, sizeof(sa.sin6_addr));
349 return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
352 #ifdef HAVE_LIBASYNCNS
354 static void asyncns_cb(pa_mainloop_api*m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags_t f, void *userdata) {
355 pa_socket_client *c = userdata;
356 struct addrinfo *res = NULL;
358 assert(m && c && c->asyncns_io_event == e && fd >= 0);
360 if (asyncns_wait(c->asyncns, 0) < 0)
363 if (!asyncns_isdone(c->asyncns, c->asyncns_query))
366 ret = asyncns_getaddrinfo_done(c->asyncns, c->asyncns_query, &res);
367 c->asyncns_query = NULL;
369 if (ret != 0 || !res)
373 sockaddr_prepare(c, res->ai_addr, res->ai_addrlen);
375 asyncns_freeaddrinfo(res);
380 errno = EHOSTUNREACH;
385 m->io_free(c->asyncns_io_event);
386 c->asyncns_io_event = NULL;
391 static void timeout_cb(pa_mainloop_api *m, pa_time_event *e, const struct timeval *tv, void *userdata) {
392 pa_socket_client *c = userdata;
407 static void start_timeout(pa_socket_client *c) {
410 assert(!c->timeout_event);
412 pa_gettimeofday(&tv);
413 pa_timeval_add(&tv, CONNECT_TIMEOUT * 1000000);
414 c->timeout_event = c->mainloop->time_new(c->mainloop, &tv, timeout_cb, c);
417 pa_socket_client* pa_socket_client_new_string(pa_mainloop_api *m, const char*name, uint16_t default_port) {
418 pa_socket_client *c = NULL;
422 if (pa_parse_address(name, &a) < 0)
426 a.port = default_port;
429 case PA_PARSED_ADDRESS_UNIX:
430 if ((c = pa_socket_client_new_unix(m, a.path_or_host)))
434 case PA_PARSED_ADDRESS_TCP4: /* Fallthrough */
435 case PA_PARSED_ADDRESS_TCP6: /* Fallthrough */
436 case PA_PARSED_ADDRESS_TCP_AUTO:{
438 struct addrinfo hints;
441 snprintf(port, sizeof(port), "%u", (unsigned) a.port);
443 memset(&hints, 0, sizeof(hints));
444 hints.ai_family = a.type == PA_PARSED_ADDRESS_TCP4 ? PF_INET : (a.type == PA_PARSED_ADDRESS_TCP6 ? PF_INET6 : PF_UNSPEC);
445 hints.ai_socktype = SOCK_STREAM;
447 #ifdef HAVE_LIBASYNCNS
451 if (!(asyncns = asyncns_new(1)))
454 c = pa_socket_client_new(m);
455 c->asyncns = asyncns;
456 c->asyncns_io_event = m->io_new(m, asyncns_fd(c->asyncns), PA_IO_EVENT_INPUT, asyncns_cb, c);
457 c->asyncns_query = asyncns_getaddrinfo(c->asyncns, a.path_or_host, port, &hints);
458 assert(c->asyncns_query);
461 #else /* HAVE_LIBASYNCNS */
463 #ifdef HAVE_GETADDRINFO
465 struct addrinfo *res = NULL;
467 ret = getaddrinfo(a.path_or_host, port, &hints, &res);
473 if ((c = pa_socket_client_new_sockaddr(m, res->ai_addr, res->ai_addrlen)))
478 #else /* HAVE_GETADDRINFO */
479 struct hostent *host = NULL;
480 struct sockaddr_in s;
482 /* FIXME: PF_INET6 support */
483 if (hints.ai_family == PF_INET6) {
484 pa_log_error(__FILE__": IPv6 is not supported on Windows");
488 host = gethostbyname(a.path_or_host);
490 unsigned int addr = inet_addr(a.path_or_host);
491 if (addr != INADDR_NONE)
492 host = gethostbyaddr((char*)&addr, 4, AF_INET);
498 s.sin_family = AF_INET;
499 memcpy(&s.sin_addr, host->h_addr, sizeof(struct in_addr));
500 s.sin_port = htons(a.port);
502 if ((c = pa_socket_client_new_sockaddr(m, (struct sockaddr*)&s, sizeof(s))))
504 #endif /* HAVE_GETADDRINFO */
506 #endif /* HAVE_LIBASYNCNS */
511 pa_xfree(a.path_or_host);
516 /* Return non-zero when the target sockaddr is considered
517 local. "local" means UNIX socket or TCP socket on localhost. Other
518 local IP addresses are not considered local. */
519 int pa_socket_client_is_local(pa_socket_client *c) {