a61cf582f7372b393513f936314a81a450845c9b
[profile/ivi/pulseaudio.git] / src / polypcore / socket-client.c
1 /* $Id$ */
2
3 /***
4   This file is part of polypaudio.
5  
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.
10  
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.
15  
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
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 /* #undef HAVE_LIBASYNCNS */
27
28 #include <unistd.h>
29 #include <stdio.h>
30 #include <errno.h>
31 #include <string.h>
32 #include <assert.h>
33 #include <stdlib.h>
34
35 #ifdef HAVE_SYS_SOCKET_H
36 #include <sys/socket.h>
37 #endif
38 #ifdef HAVE_SYS_UN_H
39 #include <sys/un.h>
40 #endif
41 #ifdef HAVE_ARPA_INET_H
42 #include <arpa/inet.h>
43 #endif
44 #ifdef HAVE_NETINET_IN_H
45 #include <netinet/in.h>
46 #endif
47 #ifdef HAVE_NETDB_H
48 #include <netdb.h>
49 #endif
50
51 #ifdef HAVE_LIBASYNCNS
52 #include <asyncns.h>
53 #endif
54
55 #include "winsock.h"
56
57 #include <polyp/xmalloc.h>
58
59 #include <polypcore/socket-util.h>
60 #include <polypcore/util.h>
61 #include <polypcore/log.h>
62 #include <polypcore/parseaddr.h>
63
64 #include "socket-client.h"
65
66 #define CONNECT_TIMEOUT 5
67
68 struct pa_socket_client {
69     int ref;
70     pa_mainloop_api *mainloop;
71     int fd;
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);
76     void *userdata;
77     int local;
78 #ifdef HAVE_LIBASYNCNS
79     asyncns_t *asyncns;
80     asyncns_query_t * asyncns_query;
81     pa_io_event *asyncns_io_event;
82 #endif
83 };
84
85 static pa_socket_client*pa_socket_client_new(pa_mainloop_api *m) {
86     pa_socket_client *c;
87     assert(m);
88
89     c = pa_xmalloc(sizeof(pa_socket_client));
90     c->ref = 1;
91     c->mainloop = m;
92     c->fd = -1;
93     c->io_event = NULL;
94     c->defer_event = NULL;
95     c->timeout_event = NULL;
96     c->callback = NULL;
97     c->userdata = NULL;
98     c->local = 0;
99
100 #ifdef HAVE_LIBASYNCNS
101     c->asyncns = NULL;
102     c->asyncns_io_event = NULL;
103     c->asyncns_query = NULL;
104 #endif
105
106     return c;
107 }
108
109 static void free_events(pa_socket_client *c) {
110     assert(c);
111     
112     if (c->io_event) {
113         c->mainloop->io_free(c->io_event);
114         c->io_event = NULL;
115     }
116     
117     if (c->defer_event) {
118         c->mainloop->defer_free(c->defer_event);
119         c->defer_event = NULL;
120     }
121     
122     if (c->timeout_event) {
123         c->mainloop->time_free(c->timeout_event);
124         c->timeout_event = NULL;
125     }
126 }
127
128 static void do_call(pa_socket_client *c) {
129     pa_iochannel *io = NULL;
130     int error;
131     socklen_t lerror;
132     assert(c && c->callback);
133
134     pa_socket_client_ref(c);
135
136     if (c->fd < 0)
137         goto finish;
138     
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));
142         goto finish;
143     }
144
145     if (lerror != sizeof(error)) {
146         pa_log(__FILE__": getsockopt() returned invalid size.");
147         goto finish;
148     }
149
150     if (error != 0) {
151         pa_log_debug(__FILE__": connect(): %s", strerror(error)); 
152         errno = error;
153         goto finish;
154     }
155
156     io = pa_iochannel_new(c->mainloop, c->fd, c->fd);
157     assert(io);
158     
159 finish:
160     if (!io && c->fd >= 0)
161         close(c->fd);
162     c->fd = -1;
163
164     free_events(c);
165     
166     assert(c->callback);
167     c->callback(c, io, c->userdata);
168     
169     pa_socket_client_unref(c);
170 }
171
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);
175     do_call(c);
176 }
177
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);
181     do_call(c);
182 }
183
184 static int do_connect(pa_socket_client *c, const struct sockaddr *sa, socklen_t len) {
185     int r;
186     assert(c && sa && len);
187     
188     pa_make_nonblock_fd(c->fd);
189     
190     if ((r = connect(c->fd, sa, len)) < 0) {
191 #ifdef OS_IS_WIN32
192         if (WSAGetLastError() != EWOULDBLOCK) {
193             pa_log_debug(__FILE__": connect(): %d", WSAGetLastError());
194 #else
195         if (errno != EINPROGRESS) {
196             pa_log_debug(__FILE__": connect(): %s (%d)", strerror(errno), errno);
197 #endif
198             return -1;
199         }
200
201         c->io_event = c->mainloop->io_new(c->mainloop, c->fd, PA_IO_EVENT_OUTPUT, connect_io_cb, c);
202         assert(c->io_event);
203     } else {
204         c->defer_event = c->mainloop->defer_new(c->mainloop, connect_fixed_cb, c);
205         assert(c->defer_event);
206     }
207
208     return 0;
209 }
210
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);
214
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);
219
220     return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
221 }
222
223 #ifdef HAVE_SYS_UN_H
224
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);
228     
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;
233
234     return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
235 }
236
237 #else /* HAVE_SYS_UN_H */
238
239 pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename) {
240     return NULL;
241 }
242
243 #endif /* HAVE_SYS_UN_H */
244
245 static int sockaddr_prepare(pa_socket_client *c, const struct sockaddr *sa, size_t salen) {
246     assert(c);
247     assert(sa);
248     assert(salen);
249     
250     switch (sa->sa_family) {
251         case AF_UNIX:
252             c->local = 1;
253             break;
254             
255         case AF_INET:
256             c->local = ((const struct sockaddr_in*) sa)->sin_addr.s_addr == INADDR_LOOPBACK;
257             break;
258             
259         case AF_INET6:
260             c->local = memcmp(&((const struct sockaddr_in6*) sa)->sin6_addr, &in6addr_loopback, sizeof(struct in6_addr)) == 0;
261             break;
262             
263         default:
264             c->local = 0;
265     }
266     
267     if ((c->fd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0) {
268         pa_log(__FILE__": socket(): %s", strerror(errno));
269         return -1;
270     }
271
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);
275     else
276         pa_socket_low_delay(c->fd);
277
278     if (do_connect(c, sa, salen) < 0)
279         return -1;
280
281     return 0;
282 }
283
284 pa_socket_client* pa_socket_client_new_sockaddr(pa_mainloop_api *m, const struct sockaddr *sa, size_t salen) {
285     pa_socket_client *c;
286     assert(m && sa);
287     c = pa_socket_client_new(m);
288     assert(c);
289
290     if (sockaddr_prepare(c, sa, salen) < 0)
291         goto fail;
292     
293     return c;
294
295 fail:
296     pa_socket_client_unref(c);
297     return NULL;
298     
299 }
300
301 static void socket_client_free(pa_socket_client *c) {
302     assert(c && c->mainloop);
303
304
305     free_events(c);
306     
307     if (c->fd >= 0)
308         close(c->fd);
309
310 #ifdef HAVE_LIBASYNCNS
311     if (c->asyncns_query)
312         asyncns_cancel(c->asyncns, c->asyncns_query);
313     if (c->asyncns)
314         asyncns_free(c->asyncns);
315     if (c->asyncns_io_event)
316         c->mainloop->io_free(c->asyncns_io_event);
317 #endif
318     
319     pa_xfree(c);
320 }
321
322 void pa_socket_client_unref(pa_socket_client *c) {
323     assert(c && c->ref >= 1);
324
325     if (!(--(c->ref)))
326         socket_client_free(c);
327 }
328
329 pa_socket_client* pa_socket_client_ref(pa_socket_client *c) {
330     assert(c && c->ref >= 1);
331     c->ref++;
332     return c;
333 }
334
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) {
336     assert(c);
337     c->callback = on_connection;
338     c->userdata = userdata;
339 }
340
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;
343     
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));
348
349     return pa_socket_client_new_sockaddr(m, (struct sockaddr*) &sa, sizeof(sa));
350 }
351
352 #ifdef HAVE_LIBASYNCNS
353
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;
357     int ret;
358     assert(m && c && c->asyncns_io_event == e && fd >= 0);
359
360     if (asyncns_wait(c->asyncns, 0) < 0)
361         goto fail;
362
363     if (!asyncns_isdone(c->asyncns, c->asyncns_query))
364         return;
365
366     ret = asyncns_getaddrinfo_done(c->asyncns, c->asyncns_query, &res);
367     c->asyncns_query = NULL;
368
369     if (ret != 0 || !res)
370         goto fail;
371     
372     if (res->ai_addr)
373         sockaddr_prepare(c, res->ai_addr, res->ai_addrlen);
374     
375     asyncns_freeaddrinfo(res);
376
377     goto finish;
378
379 fail:
380     errno = EHOSTUNREACH;
381     do_call(c);
382     
383 finish:
384     
385     m->io_free(c->asyncns_io_event);
386     c->asyncns_io_event = NULL;
387 }
388
389 #endif
390
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;
393     assert(m);
394     assert(e);
395     assert(tv);
396     assert(c);
397
398     if (c->fd >= 0) {
399         close(c->fd);
400         c->fd = -1;
401     }
402
403     errno = ETIMEDOUT;
404     do_call(c);
405 }
406
407 static void start_timeout(pa_socket_client *c) {
408     struct timeval tv;
409     assert(c);
410     assert(!c->timeout_event);
411
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);
415 }
416
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;
419     pa_parsed_address a;
420     assert(m && name);
421
422     if (pa_parse_address(name, &a) < 0)
423         return NULL;
424
425     if (!a.port)
426         a.port = default_port;
427     
428     switch (a.type) {
429         case PA_PARSED_ADDRESS_UNIX:
430             if ((c = pa_socket_client_new_unix(m, a.path_or_host)))
431                 start_timeout(c);
432             break;
433
434         case PA_PARSED_ADDRESS_TCP4:  /* Fallthrough */
435         case PA_PARSED_ADDRESS_TCP6:  /* Fallthrough */
436         case PA_PARSED_ADDRESS_TCP_AUTO:{
437
438             struct addrinfo hints;
439             char port[12];
440
441             snprintf(port, sizeof(port), "%u", (unsigned) a.port);
442
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;
446             
447 #ifdef HAVE_LIBASYNCNS
448             {
449                 asyncns_t *asyncns;
450                 
451                 if (!(asyncns = asyncns_new(1)))
452                     goto finish;
453
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);
459                 start_timeout(c);
460             }
461 #else /* HAVE_LIBASYNCNS */
462             {
463 #ifdef HAVE_GETADDRINFO
464                 int ret;
465                 struct addrinfo *res = NULL;
466
467                 ret = getaddrinfo(a.path_or_host, port, &hints, &res);
468                 
469                 if (ret < 0 || !res)
470                     goto finish;
471
472                 if (res->ai_addr) {
473                     if ((c = pa_socket_client_new_sockaddr(m, res->ai_addr, res->ai_addrlen)))
474                         start_timeout(c);
475                                 }
476                 
477                 freeaddrinfo(res);
478 #else /* HAVE_GETADDRINFO */
479                 struct hostent *host = NULL;
480                 struct sockaddr_in s;
481
482                 /* FIXME: PF_INET6 support */
483                 if (hints.ai_family == PF_INET6) {
484                     pa_log_error(__FILE__": IPv6 is not supported on Windows");
485                     goto finish;
486                 }
487
488                 host = gethostbyname(a.path_or_host);
489                 if (!host) {
490                     unsigned int addr = inet_addr(a.path_or_host);
491                     if (addr != INADDR_NONE)
492                         host = gethostbyaddr((char*)&addr, 4, AF_INET);
493                 }
494
495                 if (!host)
496                     goto finish;
497
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);
501
502                 if ((c = pa_socket_client_new_sockaddr(m, (struct sockaddr*)&s, sizeof(s))))
503                         start_timeout(c);
504 #endif /* HAVE_GETADDRINFO */
505             }
506 #endif /* HAVE_LIBASYNCNS */
507         }
508     }
509
510 finish:
511     pa_xfree(a.path_or_host);
512     return c;
513     
514 }
515
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) {
520     assert(c);
521     return c->local;
522 }