source: roaraudio/libroar/socket.c @ 4939:283c00842296

Last change on this file since 4939:283c00842296 was 4939:283c00842296, checked in by phi, 13 years ago

some minor fixes for win32
File size: 28.8 KB
Line 
1//socket.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2011
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38#define MODE_LISTEN  ROAR_SOCKET_MODE_LISTEN
39#define MODE_CONNECT ROAR_SOCKET_MODE_CONNECT
40
41#ifdef ROAR_TARGET_WIN32
42void roar_socket_win32_init (void) {
43 static int inited = 0;
44 WSADATA wsadata;
45
46 if ( !inited ) {
47  WSAStartup(MAKEWORD(1,1) , &wsadata);
48  inited++;
49 }
50}
51#else
52#define roar_socket_win32_init()
53#endif
54
55int roar_socket_new_tcp (void) {
56#ifdef ROAR_HAVE_IPV4
57 int fh;
58#ifndef ROAR_TARGET_WIN32
59 int opt = IPTOS_LOWDELAY;
60#endif
61#if defined(TCP_NODELAY) && !defined(ROAR_TARGET_WIN32)
62 int t   = 1;
63#endif
64
65 roar_socket_win32_init();
66
67 fh = socket(AF_INET, SOCK_STREAM, 0);
68
69#ifndef ROAR_TARGET_WIN32
70 setsockopt(fh, IPPROTO_IP, IP_TOS, &opt, sizeof(int));
71#endif
72#if defined(TCP_NODELAY) && !defined(ROAR_TARGET_WIN32)
73 setsockopt(fh, IPPROTO_TCP, TCP_NODELAY, &t, sizeof(int));
74#endif
75
76 return fh;
77#else
78 return -1;
79#endif
80}
81
82int roar_socket_new_udp (void) {
83#ifdef ROAR_HAVE_IPV4
84 int fh;
85#ifndef ROAR_TARGET_WIN32
86 int opt = IPTOS_LOWDELAY;
87#endif
88
89 roar_socket_win32_init();
90
91 fh = socket(AF_INET, SOCK_DGRAM, 0);
92
93#ifndef ROAR_TARGET_WIN32
94 setsockopt(fh, IPPROTO_IP, IP_TOS, &opt, sizeof(int));
95#endif
96
97 return fh;
98#else
99 return -1;
100#endif
101}
102
103int roar_socket_new_tcp6 (void) {
104#ifdef ROAR_HAVE_IPV6
105 int fh;
106 int opt = IPTOS_LOWDELAY;
107
108 roar_socket_win32_init();
109
110 fh = socket(AF_INET6, SOCK_STREAM, 0);
111
112 setsockopt(fh, IPPROTO_IP, IP_TOS, &opt, sizeof(int));
113
114 return fh;
115#else
116 return -1;
117#endif
118}
119
120int roar_socket_new_udp6 (void) {
121#ifdef ROAR_HAVE_IPV6
122 int fh;
123 int opt = IPTOS_LOWDELAY;
124
125 roar_socket_win32_init();
126
127 fh = socket(AF_INET6, SOCK_DGRAM, 0);
128
129 setsockopt(fh, IPPROTO_IP, IP_TOS, &opt, sizeof(int));
130
131 return fh;
132#else
133 return -1;
134#endif
135}
136
137int roar_socket_new_unix (void) {
138#ifdef ROAR_HAVE_UNIX
139 int fh;
140/*
141#ifdef SO_PEERCRED
142 int opt = 1;
143#endif
144*/
145
146 fh = socket(AF_UNIX, SOCK_STREAM, 0);
147
148/*
149#ifdef SO_PEERCRED
150// setsockopt(fh, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(int));
151#endif
152*/
153
154 return fh;
155#else
156 return -1;
157#endif
158}
159
160int roar_socket_decnet_set_timeout (int fh, time_t sec, int usec) {
161#ifdef ROAR_HAVE_LIBDNET
162 struct timeval timeout = {sec, usec};
163
164 return setsockopt(fh, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
165#else
166 return -1;
167#endif
168}
169
170int roar_socket_recvbuf(int fh, int len) {
171#ifdef ROAR_HAVE_BSDSOCKETS
172 if ( len < 256 ) len = 256;
173
174 return setsockopt(fh, SOL_SOCKET, SO_RCVBUF, (void *)&len, sizeof(len));
175#else
176 return -1;
177#endif
178}
179
180int roar_socket_new_decnet_seqpacket (void) {
181#ifdef ROAR_HAVE_LIBDNET
182 int fh;
183
184 fh = socket(AF_DECnet, SOCK_SEQPACKET, DNPROTO_NSP);
185
186 roar_socket_decnet_set_timeout(fh, 300, 0);
187
188 return fh;
189#else
190 return -1;
191#endif
192}
193
194
195int roar_socket_new_decnet_stream (void) {
196#ifdef ROAR_HAVE_LIBDNET
197 int fh;
198
199 fh = socket(AF_DECnet, SOCK_STREAM, DNPROTO_NSP);
200
201 roar_socket_decnet_set_timeout(fh, 300, 0);
202
203 return fh;
204#else
205 return -1;
206#endif
207}
208
209int roar_socket_new_ipxspx (void) {
210 return -1;
211}
212
213int roar_socket_new_ipx    (void) {
214#ifdef ROAR_HAVE_IPX
215 return socket(AF_IPX, SOCK_DGRAM, AF_IPX);
216#else
217 return -1;
218#endif
219}
220
221
222int roar_socket_nonblock(int fh, int state) {
223#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER) && defined(ROAR_HAVE_FCNTL)
224 int flags;
225
226 if ( (flags = fcntl(fh, F_GETFL, 0)) == -1 ) {
227  ROAR_ERR("roar_socket_nonblock(fh=%i, state=%i): Can not read flags: %s", fh, state, strerror(errno));
228  ROAR_DBG("roar_socket_nonblock(fh=%i, state=%i) = -1", fh, state);
229  return -1;
230 }
231
232 if ( !(flags & O_NONBLOCK) && state == ROAR_SOCKET_BLOCK )
233  return 0;
234
235 flags |= O_NONBLOCK;
236
237 if ( state == ROAR_SOCKET_BLOCK )
238  flags -= O_NONBLOCK;
239
240 if ( fcntl(fh, F_SETFL, flags) == -1 ) {
241  ROAR_ERR("roar_socket_nonblock(fh=%i, state=%i): Can not set flags: %s", fh, state, strerror(errno));
242  ROAR_DBG("roar_socket_nonblock(fh=%i, state=%i) = -1", fh, state);
243  return -1;
244 }
245
246 ROAR_DBG("roar_socket_nonblock(fh=%i, state=%i) = 0", fh, state);
247 return 0;
248#else
249 ROAR_WARN("roar_socket_nonblock(*): no nonblocking IO support on win32, use a real OS");
250 return -1;
251#endif
252}
253
254int roar_socket_dup_udp_local_end (int fh) {
255#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER) && defined(ROAR_HAVE_FCNTL)
256 int                  n              = -1;
257 int                  flags          = -1;
258 struct sockaddr_in   socket_addr;
259 socklen_t            len            = sizeof(struct sockaddr_in);
260
261 if ( (flags = fcntl(fh, F_GETFL, 0)) == -1 ) {
262  ROAR_WARN("roar_socket_dup_udp_local_end(fh=%i): Can not read flags: %s", fh, strerror(errno));
263 }
264
265 if ( getsockname(fh, (struct sockaddr *)&socket_addr, &len) == -1 ) {
266  return -1;
267 }
268
269 if ( socket_addr.sin_family != AF_INET ) {
270  return -1;
271 }
272
273 n = roar_socket_new_udp();
274
275 if ( n == -1 )
276  return -1;
277
278//  if ( mode_func(fh, (struct sockaddr *)&socket_addr, sizeof(struct sockaddr_in)) == -1 ) {
279 if ( bind(n, (struct sockaddr *)&socket_addr, len) == -1 ) {
280  close(n);
281  return -1;
282 }
283
284 if ( flags != -1 ) {
285  if ( fcntl(fh, F_SETFL, flags) == -1 ) {
286   ROAR_WARN("roar_socket_dup_udp_local_end(fh=%i): Can not set flags: %s", fh, strerror(errno));
287   return -1;
288  }
289 }
290
291
292 return n;
293#else
294 ROAR_WARN("roar_socket_dup_udp_local_end(*): this function is not supported on win32, use a real OS");
295 return -1;
296#endif
297}
298
299
300#define _SCMR_CONTROLLEN (sizeof(struct cmsghdr) + sizeof(int))
301int roar_socket_send_fh (int sock, int fh, char * mes, size_t len) {
302#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER) && !defined(ROAR_OS_SUNOS) && !defined(ROAR_TARGET_OPENVMS)
303 struct iovec     iov[1];
304 struct msghdr    msg;
305 char             cmptr_buf[_SCMR_CONTROLLEN];
306 struct cmsghdr * cmptr = (struct cmsghdr *) cmptr_buf;
307 char             localmes[1] = {0};
308
309 ROAR_DBG("roar_socket_send_fh(sock=%i, fh=%i, mes=%p, len=%u) = ?", sock, fh, mes, len);
310
311 if ( sock < 0 || fh < 0 )
312  return -1;
313
314 if ( len == 0 ) {
315  len = 1;
316  mes = localmes;
317 }
318
319 memset(cmptr, 0, _SCMR_CONTROLLEN);
320
321 iov[0].iov_base = mes;
322 iov[0].iov_len  = len;
323 msg.msg_iov     = iov;
324 msg.msg_iovlen  = 1;
325 msg.msg_name    = NULL;
326 msg.msg_namelen = 0;
327
328 cmptr->cmsg_level        = SOL_SOCKET;
329 cmptr->cmsg_type         = SCM_RIGHTS;
330 cmptr->cmsg_len          = _SCMR_CONTROLLEN;
331 msg.msg_control          = (caddr_t) cmptr;
332 msg.msg_controllen       = _SCMR_CONTROLLEN;
333 *(int *)CMSG_DATA(cmptr) = fh;
334
335 return sendmsg(sock, &msg, 0);
336#else
337 ROAR_ERR("roar_socket_send_fh(*): There is no UNIX Domain Socket support in win32, download a real OS.");
338 return -1;
339#endif
340}
341
342int roar_socket_recv_fh (int sock,         char * mes, size_t * len) {
343#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER) && !defined(ROAR_OS_SUNOS) && !defined(ROAR_TARGET_OPENVMS)
344 struct iovec     iov[1];
345 struct msghdr    msg;
346 char             cmptr_buf[_SCMR_CONTROLLEN];
347 struct cmsghdr * cmptr = (struct cmsghdr *) cmptr_buf;
348 char             localmes[1];
349 size_t           locallen[1] = {1};
350
351 ROAR_DBG("roar_socket_recv_fh(sock=%i, mes=%p, len=%p) = ?", sock, mes, len);
352
353 if ( sock < 0 ) {
354  ROAR_DBG("roar_socket_recv_fh(sock=%i, mes=%p, len=%p) = -1 // invalid socket", sock, mes, len);
355  return -1;
356 }
357
358 if ( len == NULL ) {
359  len = locallen;
360  mes = localmes;
361 }
362
363 iov[0].iov_base = mes;
364 iov[0].iov_len  = *len;
365 msg.msg_iov     = iov;
366 msg.msg_iovlen  = 1;
367 msg.msg_name    = NULL;
368 msg.msg_namelen = 0;
369
370 msg.msg_control    = (caddr_t) cmptr;
371 msg.msg_controllen = _SCMR_CONTROLLEN;
372
373 if ( (*len = recvmsg(sock, &msg, 0)) == -1 ) {
374  ROAR_DBG("roar_socket_recv_fh(sock=%i, mes=%p, len=%p) = -1 // can not read from socket", sock, mes, len);
375  return -1;
376 }
377
378 if ( msg.msg_controllen  < _SCMR_CONTROLLEN ||
379      cmptr->cmsg_len    != _SCMR_CONTROLLEN  ) {
380  ROAR_DBG("roar_socket_recv_fh(sock=%i, mes=%p, len=%p) = -1 // control len is wrong", sock, mes, len);
381  return -1;
382 }
383
384 ROAR_DBG("roar_socket_recv_fh(sock=%i, mes=%p, len=%p) = %i", sock, mes, len, *(int *)CMSG_DATA(cmptr));
385 return *(int *)CMSG_DATA(cmptr);
386#else
387 ROAR_ERR("roar_socket_recv_fh(*): There is no UNIX Domain Socket support in win32, download a real OS.");
388 return -1;
389#endif
390}
391
392int roar_socket_listen  (int type, char * host, int port) {
393 return roar_socket_open(MODE_LISTEN, type, host, port);
394}
395
396int roar_socket_connect (char * host, int port) {
397 char * proxy_type = getenv("ROAR_PROXY");
398
399 ROAR_DBG("roar_socket_connect(host='%s', port=%i) = ?", host, port);
400
401 if ( proxy_type == NULL || strcmp(proxy_type, "") == 0 ) {
402  return roar_socket_open(MODE_CONNECT, ROAR_SOCKET_TYPE_UNKNOWN, host, port);
403 } else {
404#ifdef ROAR_SUPPORT_PROXY
405  return roar_socket_open_proxy(MODE_CONNECT, ROAR_SOCKET_TYPE_UNKNOWN, host, port, proxy_type);
406#else
407  ROAR_ERR("roar_socket_connect(host='%s', port=%i): no support for proxy code (proxy_type=%s)", host, port, proxy_type);
408  return -1;
409#endif
410 }
411}
412
413
414int roar_socket_listen_decnet (char * object, int num) {
415#ifdef ROAR_HAVE_LIBDNET
416 int fh = roar_socket_new_decnet_stream();
417 struct sockaddr_dn bind_sockaddr;
418
419 if ( fh == -1 )
420  return -1;
421
422 if ( !*object )
423  object = NULL;
424
425 if ( (object && num) || (!*object && !num) ) {
426  ROAR_WARN("roar_socket_listen_decnet(object='%s', num=%i): illegal address!", object, num);
427  close(fh);
428  return -1;
429 }
430
431 memset((void*)&bind_sockaddr, 0, sizeof(struct sockaddr_dn));
432
433 bind_sockaddr.sdn_family    = AF_DECnet;
434 bind_sockaddr.sdn_flags     = 0;
435 bind_sockaddr.sdn_objnum    = num;
436
437 if ( num ) {
438  bind_sockaddr.sdn_objnamel = 0;
439 } else {
440  bind_sockaddr.sdn_objnamel  = ROAR_HOST2LE16(strlen(object));
441  if ( bind_sockaddr.sdn_objnamel > DN_MAXOBJL )
442   bind_sockaddr.sdn_objnamel = DN_MAXOBJL;
443  strncpy((char*)bind_sockaddr.sdn_objname, object, DN_MAXOBJL);
444 }
445
446 if ( bind(fh, (struct sockaddr *) &bind_sockaddr, sizeof(bind_sockaddr)) == -1 ) {
447  close(fh);
448  return -1;
449 }
450
451 if ( listen(fh, 8) == -1 ) {
452  close(fh);
453  return -1;
454 }
455
456 return fh;
457#else
458 return -1;
459#endif
460}
461
462char * roar_socket_get_local_nodename(void) {
463#ifdef ROAR_HAVE_LIBDNET
464 static char node[16] = {0};
465 struct dn_naddr      *binaddr;
466 struct nodeent       *dp;
467
468 if ( !node[0] ) {
469  if ( (binaddr=getnodeadd()) == NULL)
470   return NULL;
471
472  if ( (dp=getnodebyaddr((char*)binaddr->a_addr, binaddr->a_len, AF_DECnet)) == NULL )
473   return NULL;
474
475  strncpy(node, dp->n_name, 15);
476  node[15] = 0;
477 }
478
479 return node;
480#else
481 return NULL;
482#endif
483}
484
485int roar_socket_open (int mode, int type, char * host, int port) {
486// int type = ROAR_SOCKET_TYPE_INET;
487 int fh;
488#ifdef ROAR_HAVE_IPX
489#define _NEED_OBJ
490 int ret;
491#endif
492#ifdef ROAR_HAVE_IPX
493 unsigned int ipx_port;
494#endif
495#ifdef ROAR_HAVE_UNIX
496 int abstract = 0;
497#endif
498#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6) || defined(ROAR_HAVE_UNIX) || defined(ROAR_HAVE_IPX)
499 union {
500  struct sockaddr     sa;
501#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
502  struct sockaddr_in  in;
503#endif
504#ifdef ROAR_HAVE_UNIX
505  struct sockaddr_un  un;
506#endif
507#ifdef ROAR_HAVE_IPV6
508  struct sockaddr_in6 in6;
509#endif
510#ifdef ROAR_HAVE_IPX
511  struct sockaddr_ipx ipx;
512#endif
513 } socket_addr;
514 socklen_t addrlen;
515#endif
516#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
517 struct hostent     * he;
518#endif
519 //unsigned int host_div = 0;
520#ifdef ROAR_TARGET_WIN32
521 int PASCAL (*mode_func)(SOCKET,const struct sockaddr*,int) = connect; // default is to connect
522#else
523 int (*mode_func)(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) = connect; // default is to connect
524#endif
525#ifdef ROAR_HAVE_LIBDNET
526#define _NEED_OBJ
527#endif
528#ifdef _NEED_OBJ
529 char obj[80];
530 char * del;
531#endif
532 int af_guessed = 0;
533#ifdef ROAR_HAVE_GETADDRINFO
534 struct addrinfo hints, *res = NULL;
535 char port_as_string[32];
536#endif
537
538 ROAR_DBG("roar_socket_open(mode=%i, type=%i, host='%s', port=%i) = ?", mode, type, host, port);
539
540 if ( mode == MODE_LISTEN )
541  mode_func = bind;
542
543 if ( type == ROAR_SOCKET_TYPE_UNKNOWN ) {
544  af_guessed = 1;
545  type = ROAR_SOCKET_TYPE_INET;
546  if ( *host == '/' ) {
547   type = ROAR_SOCKET_TYPE_UNIX;
548  } else if ( strcmp(host, "+fork") == 0 ) {
549   type = ROAR_SOCKET_TYPE_FORK;
550  } else if ( strcmp(host, "+abstract") == 0 ) {
551   type = ROAR_SOCKET_TYPE_UNIX;
552#ifdef ROAR_HAVE_UNIX
553   abstract = 1;
554#endif
555  } else if ( strstr(host, "::") != NULL ) {
556   type = ROAR_SOCKET_TYPE_DECNET;
557  } else if ( host[strlen(host)-1] == ')' ) {
558   type = ROAR_SOCKET_TYPE_IPX;
559  }
560 }
561
562
563 ROAR_DBG("roar_socket_open(mode=%i, type=%i, host='%s', port=%i) = ?", mode, type, host, port);
564
565 ROAR_DBG("roar_socket_open(*): type=%s, host='%s', port=%i",
566             type == ROAR_SOCKET_TYPE_UNIX ? "UNIX" : "???", host, port);
567
568 if ( type == ROAR_SOCKET_TYPE_DECNET ) {
569#ifdef ROAR_HAVE_LIBDNET
570   ROAR_DBG("roar_socket_open(*): hostname for DECnet: host(%p)=%s", host, host);
571   del = strstr(host, "::");
572   ROAR_DBG("roar_socket_open(*): hostname for DECnet: del(%p)=%s", del, del);
573
574   if ( del == NULL ) {
575    ROAR_WARN("roar_socket_open(*): invalid hostname for DECnet: %s", host);
576    return -1;
577   }
578
579   *del = 0;
580
581   if ( *(del+2) == '#' ) { // assume we have node::#num
582    port = atoi(del+2);
583   }
584
585   if ( port ) {
586    snprintf(obj, 7, "%i", port); // no need for snprintf() as dec(port) is smaller than obj[]
587   } else {
588    *obj = 0;
589    strncat(obj, del+2, 79);
590   }
591
592  if ( mode == MODE_LISTEN ) {
593   fh = roar_socket_listen_decnet(obj, port);
594   *del = ':';
595   return fh;
596//   return -1; // listen sockets on DECnet are not supportet at the moment
597  } else {
598   // There is nothing wrong in this case to use dnet_conn() so we do.
599   fh = dnet_conn(host, obj, SOCK_STREAM, 0 ,0 ,0 , 0);
600   *del = ':';
601   return fh;
602  }
603#else
604  return -1; // no decnet support
605#endif
606 }
607
608#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
609 memset(&socket_addr,    0, sizeof(socket_addr));
610 memset(&he,             0, sizeof(he));               // FIXME: we have a valid pointer in here????
611#endif
612
613
614 if ( type == ROAR_SOCKET_TYPE_INET || type == ROAR_SOCKET_TYPE_INET6 ) {
615#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
616
617  ROAR_DBG("roar_socket_open(*): type=INET|INET6, host='%s', port=%i", host, port);
618
619  roar_socket_win32_init(); // we need to do this early as gethostbyname() requires this.
620
621  ROAR_DBG("roar_socket_open(*): type=INET|INET6, host='%s', port=%i", host, port);
622
623#ifdef ROAR_HAVE_GETADDRINFO
624  memset(&hints, 0, sizeof(hints));
625  hints.ai_socktype = SOCK_STREAM;
626  if ( af_guessed ) {
627   hints.ai_family   = AF_UNSPEC;
628  } else {
629   hints.ai_family   = type == ROAR_SOCKET_TYPE_INET ? AF_INET : AF_INET6;
630  }
631
632  snprintf(port_as_string, sizeof(port_as_string), "%i", port);
633
634  if ( getaddrinfo(host, port_as_string, &hints, &res) != 0 )
635   return -1;
636
637  if ( af_guessed ) {
638   type = res->ai_family == AF_INET ? ROAR_SOCKET_TYPE_INET : ROAR_SOCKET_TYPE_INET6;
639  }
640
641  if ( type == ROAR_SOCKET_TYPE_INET ) {
642   fh = roar_socket_new_tcp();
643  } else {
644   fh = roar_socket_new_tcp6();
645  }
646
647  memcpy(&(socket_addr.sa), res->ai_addr, res->ai_addrlen);
648  addrlen = res->ai_addrlen;
649
650  if ( res != NULL )
651   freeaddrinfo(res);
652#else
653  if ( (he = gethostbyname(host)) == NULL ) {
654   ROAR_ERR("roar_socket_open(*): Can\'t resolve host name '%s'",
655                     host);
656   return -1;
657  }
658
659   ROAR_DBG("roar_socket_open(*): he=%p", he);
660
661   memcpy((struct in_addr *)&(socket_addr.in.sin_addr), he->h_addr, sizeof(struct in_addr));
662
663   /* set the connect information */
664   socket_addr.in.sin_family = AF_INET;
665   socket_addr.in.sin_port   = ROAR_HOST2NET16(port);
666
667  fh = roar_socket_new_tcp();
668  addrlen = sizeof(struct sockaddr_in);
669#endif
670
671  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
672
673  if ( fh == -1 ) {
674   ROAR_ERR("roar_socket_open(*): Can\'t create TCP socket: %s", strerror(errno));
675   return -1;
676  }
677
678  ROAR_DBG("roar_socket_open(*) = ?");
679
680  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
681
682   if ( mode_func(fh, (struct sockaddr *)&socket_addr.sa, addrlen) == -1 ) {
683    ROAR_DBG("roar_socket_open(*): Can not connect/bind: %s", strerror(errno));
684    close(fh);
685    return -1;
686   }
687
688  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
689
690  // hey! we have a socket...
691  ROAR_DBG("roar_socket_open(*) = ? // we have a socket :)");
692#else
693  ROAR_DBG("roar_socket_open(*) = -1 // no IPv4 or IPv6 support");
694  return -1;
695#endif
696 } else if ( type == ROAR_SOCKET_TYPE_UNIX ) {
697#ifdef ROAR_HAVE_UNIX
698  socket_addr.un.sun_family = AF_UNIX;
699
700  if ( abstract ) {
701   memset(socket_addr.un.sun_path, 0, sizeof(socket_addr.un.sun_path));
702   snprintf(socket_addr.un.sun_path+1, sizeof(socket_addr.un.sun_path)-1, "RoarAudio/UNIX/Abstract/%i", abstract);
703  } else {
704   strncpy(socket_addr.un.sun_path, host, sizeof(socket_addr.un.sun_path) - 1);
705  }
706
707  fh = roar_socket_new_unix();
708
709  if ( mode_func(fh, (struct sockaddr *)&socket_addr.un, sizeof(struct sockaddr_un)) == -1 ) {
710   ROAR_DBG("roar_socket_open(*): Can not connect/bind: %s", strerror(errno));
711   close(fh);
712   return -1;
713  }
714#else
715  ROAR_ERR("roar_socket_open(*): There is no UNIX Domain Socket support in win32, download a real OS.");
716  return -1;
717#endif
718 } else if ( type == ROAR_SOCKET_TYPE_IPX ) {
719#ifdef ROAR_HAVE_IPX
720  socket_addr.ipx.sipx_family = AF_IPX;
721
722  obj[0] = 0;
723
724  if ( (ret = sscanf(host, "%8x.%12s(%x)", &socket_addr.ipx.sipx_network, obj, &ipx_port)) < 2 ) {
725   return -1;
726   socket_addr.ipx.sipx_port = ipx_port;
727  } else if ( ret == 2 ) {
728   socket_addr.ipx.sipx_port = port; // Network Byte Order?
729  }
730
731  memset(socket_addr.ipx.sipx_node, 0, IPX_NODE_LEN);
732  ret = strlen(obj);
733
734  if ( ret % 2 )  // needs to be even at the moment
735   return -1;
736
737  fh = roar_socket_new_ipx();
738
739  close(fh);
740  return -1;
741#else
742  return -1;
743#endif
744 } else if ( type == ROAR_SOCKET_TYPE_FORK ) {
745  return roar_socket_open_fork(mode, host, port);
746 } else if ( type == ROAR_SOCKET_TYPE_FILE ) {
747  return roar_socket_open_file(mode, host, port);
748 } else {
749  return -1;
750 }
751
752 if ( mode == MODE_LISTEN ) {
753#if defined(ROAR_HAVE_BSDSOCKETS) || defined(ROAR_TARGET_WIN32)
754  if ( listen(fh, ROAR_SOCKET_QUEUE_LEN) == -1 ) {
755   close(fh);
756   return -1;
757  }
758#else
759  return -1;
760#endif
761 }
762
763 return fh;
764}
765
766int roar_socket_open_fork  (int mode, char * host, int port) {
767#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
768 char * daemonimage;
769 int socks[2];
770 int r;
771 char fhstr[8];
772
773 if ( mode == MODE_LISTEN )
774  return -1;
775
776 // TODO: FIXME: we should move this into the config structure.
777 daemonimage = getenv("ROAR_DAEMONIMAGE");
778
779 if ( daemonimage == NULL || *daemonimage == 0 )
780  daemonimage = "roard";
781
782 if ( socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1 ) {
783  return -1;
784 }
785
786 r = fork();
787
788 if ( r == -1 ) { // error!
789  ROAR_ERR("roar_socket_open_fork(*): Can not fork: %s", strerror(errno));
790  close(socks[0]);
791  close(socks[1]);
792  return -1;
793 } else if ( r == 0 ) { // we are the child
794  close(socks[0]);
795
796  close(ROAR_STDIN ); // we do not want roard to have any standard input
797  close(ROAR_STDOUT); // STDOUT is also not needed, so we close it,
798                      // but STDERR we keep open for error messages.
799
800  snprintf(fhstr, 7, "%i", socks[1]);
801
802  execlp(daemonimage, daemonimage, "--no-listen", "--client-fh", fhstr, (char*)NULL);
803
804  // we are still alive?
805  ROAR_ERR("roar_socket_open_fork(*): alive after exec(), that's bad!");
806  _exit(1);
807 } else { // we are the parent
808  close(socks[1]);
809  return socks[0];
810 }
811
812 return -1;
813#else
814 ROAR_ERR("roar_socket_open_fork(*): There is no UNIX Domain Socket support in win32, download a real OS.");
815 return -1;
816#endif
817}
818
819int roar_socket_open_file  (int mode, char * host, int port) {
820#ifdef ROAR_HAVE_IO_POSIX
821 int fh;
822
823 if ( mode == MODE_LISTEN )
824  return -1;
825
826 if ( (fh = open(host, O_RDONLY, 0644)) == -1 ) {
827  ROAR_ERR("roar_socket_open_file(*): Can not open file %s: %s", host, strerror(errno));
828 }
829
830 return fh;
831#else
832 return -1;
833#endif
834}
835
836// --- [ PROXY CODE ] ---
837
838#ifndef ROAR_HAVE_IO_POSIX
839#ifdef  ROAR_SUPPORT_PROXY
840#undef  ROAR_SUPPORT_PROXY
841#endif
842#endif
843
844// generic proxy code:
845
846#ifdef ROAR_SUPPORT_PROXY
847int roar_socket_open_proxy (int mode, int type, char * host, int port, char * proxy_type) {
848 int    proxy_port = -1;
849 char   proxy_host[ROAR_SOCKET_MAX_HOSTNAMELEN];
850 char * proxy_addr = NULL;
851 int    i;
852 int    fh = -1;
853 char * user = NULL, * pw = NULL, * opts = NULL;
854 char * sep;
855 int    no_fh = 0;
856 char   proxy_addr_buf[1024];
857 static struct passwd * passwd;
858 int (* code)(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) = NULL;
859
860 if ( passwd == NULL ) {
861  passwd = getpwuid(getuid());
862 }
863
864// TODO: fix this in a good way
865#ifndef ROAR_TARGET_MICROCONTROLLER
866 if ( passwd != NULL )
867  user = passwd->pw_name;
868#endif
869
870 if ( user == NULL )
871  user = getenv("USER");
872
873 // TODO: change this so we support listen() proxys (ssh -R)
874 if ( mode != MODE_CONNECT )
875  return -1;
876
877 if ( !strncmp(proxy_type, "socks", 5) ) {
878  proxy_addr = getenv("socks_proxy");
879
880  proxy_port = 9050; // TOR's default port
881 } else if ( !strcmp(proxy_type, "http") || !strcmp(proxy_type, "https") ) {
882  proxy_port = 8080;
883
884  if ( (proxy_addr = getenv("http_proxy")) == NULL )
885   proxy_addr = getenv("https_proxy");
886
887  if ( proxy_addr == NULL )
888   return -1;
889
890  if ( !strncmp(proxy_addr, "http://", 7) )
891   proxy_addr += 7;
892 } else if ( !strncmp(proxy_type, "ssh", 3) ) {
893  proxy_port = 22;
894  proxy_addr = getenv("ssh_proxy");
895  no_fh      = 1;
896 }
897
898 proxy_addr_buf[1023] = 0;
899 strncpy(proxy_addr_buf, proxy_addr, 1023);
900 proxy_addr = proxy_addr_buf;
901
902 if ( (sep = strstr(proxy_type, "/")) != NULL )
903  opts = sep+1;
904
905 if ( proxy_addr == NULL )
906  return -1;
907
908 if ( (sep = strstr(proxy_addr, "@")) != NULL ) {
909  *sep = 0;
910  user = proxy_addr;
911  proxy_addr = sep+1;
912
913  if ( (sep = strstr(user, ":")) != NULL ) {
914   *sep = 0;
915   pw = sep+1;
916  }
917 }
918
919 ROAR_DBG("roar_socket_open_proxy(*): proxy_type='%s', opts='%s', user='%s', pw=(not shown), proxy_addr='%s'", proxy_type, opts, user, proxy_addr);
920
921 for (i = 0; proxy_addr[i] != 0 && proxy_addr[i] != ':' && i < (ROAR_SOCKET_MAX_HOSTNAMELEN - 1); i++)
922  proxy_host[i] = proxy_addr[i];
923 proxy_host[i] = 0;
924
925 if ( i == 0 ) // no hostname found
926  return -1;
927
928 if ( proxy_addr[i] == ':' )
929  proxy_port = atoi(&proxy_addr[i+1]);
930
931 if ( ! no_fh ) {
932  if ( (fh = roar_socket_open(mode, type, proxy_host, proxy_port)) == -1) {
933   return -1;
934  }
935 }
936
937 if ( !strcmp(proxy_type, "socks4a") ) { // for TOR, the only supported type at the moment
938  code = roar_socket_open_socks4a;
939 } else if ( !strcmp(proxy_type, "socks4d") ) { // DECnet
940  code = roar_socket_open_socks4d;
941 } else if ( !strcmp(proxy_type, "socks4") ) { // good old SOCKS4
942  code = roar_socket_open_socks4;
943 } else if ( !strcmp(proxy_type, "http") ) { // HTTP CONNECT
944  code = roar_socket_open_http;
945 } else if ( !strncmp(proxy_type, "ssh", 3) ) { // SSH...
946#ifdef ROAR_HAVE_BIN_SSH
947  code = roar_socket_open_ssh;
948#else
949  ROAR_ERR("roar_socket_open_proxy(*): No SSH support compiled in");
950#endif
951 } else {
952  return -1; // unknown type
953 }
954
955 if ( code != NULL ) {
956  if ( no_fh ) {
957   fh = code(mode, fh, host, port, user, pw, opts);
958  } else {
959   if ( code(mode, fh, host, port, user, pw, opts) == -1 ) {
960    close(fh);
961    return -1;
962   }
963  }
964
965  return fh;
966 }
967
968 close(fh);
969 return -1;
970}
971
972// protocoll dependet proxy code:
973
974int roar_socket_open_socks4 (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
975#ifndef ROAR_TARGET_MICROCONTROLLER
976 struct hostent     * he;
977
978 if ( (he = gethostbyname(host)) == NULL ) {
979  ROAR_ERR("roar_socket_open_socks4(*): Can\'t resolve host name '%s'", host);
980  return -1;
981 }
982
983 return roar_socket_open_socks4x(mode, fh, he->h_addr, port, NULL, 0, user);
984#else
985 return -1;
986#endif
987}
988
989int roar_socket_open_socks4a(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
990 return roar_socket_open_socks4x(mode, fh, "\0\0\0\1", port, host, strlen(host)+1, user);
991}
992
993int roar_socket_open_socks4d(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
994 size_t len = strlen(host)+1;
995 char * dp;
996
997 if ( port == 0 ) {
998  if ( (dp = strstr(host, "::")) == NULL )
999   return -1;
1000
1001  len--;
1002  *dp = 0;
1003  memmove(dp+1, dp+2, len - (dp-host) - 1);
1004 }
1005
1006 return roar_socket_open_socks4x(mode, fh, "\0\2\0\0", port, host, len, user);
1007}
1008
1009int roar_socket_open_socks4x(int mode, int fh, char host[4], int port, char * app, size_t app_len, char * user) {
1010 char buf[9];
1011 int len;
1012
1013 buf[0] = 0x04;
1014 buf[1] = mode == MODE_CONNECT ? 0x01 : 0x02;
1015 *((uint16_t*)&buf[2]) = htons(port);
1016 memcpy(buf+4, host, 4);
1017
1018 if ( user == NULL ) {
1019  buf[8] = 0x00;
1020  len = 9;
1021 } else {
1022  len = 8;
1023 }
1024
1025 if ( write(fh, buf, len) != len )
1026  return -1;
1027
1028 if ( user != NULL ) {
1029  len = strlen(user) + 1;
1030  if ( write(fh, user, len) != len )
1031   return -1;
1032 }
1033
1034 if ( app_len > 0 )
1035  if ( write(fh, app, app_len) != app_len )
1036   return -1;
1037
1038 if ( read(fh, buf, 8) != 8 )
1039  return -1;
1040
1041 if ( buf[1] != 0x5a )
1042  return -1;
1043
1044 return 0;
1045}
1046
1047int roar_socket_open_http   (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
1048 char buf[1024];
1049 int len;
1050
1051 if ( port == 0 || host == NULL )
1052  return -1;
1053
1054 if ( *host == '/' ) // AF_UNIX
1055  return -1;
1056
1057 if ( (len = snprintf(buf, 1024, "CONNECT %s:%i HTTP/1.0\r\nUser-Agent: libroar\r\n\r\n", host, port)) == -1 )
1058  return -1;
1059
1060 if ( write(fh, buf, len) != len )
1061  return -1;
1062
1063 while ( (len = read(fh, buf, 1024)) ) {
1064  if ( len == 1024 ) { // overlong lion
1065   return -1;
1066  } else if ( len == 2 && buf[0] == '\r' && buf[1] == '\n' ) {
1067   break;
1068  } else if ( len == 1 && (buf[0] == '\r' || buf[0] == '\n') ) { // bad proxy or devel trying to debug ;)
1069   break;
1070  } else if ( len >= 4 && buf[len-4] == '\r' && buf[len-3] == '\n' && buf[len-2] == '\r' && buf[len-1] == '\n' ) {
1071   break;
1072  }
1073 }
1074
1075 return 0;
1076}
1077
1078
1079#ifdef ROAR_HAVE_BIN_SSH
1080int roar_socket_open_ssh    (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
1081 char * proxy_addr = getenv("ssh_proxy");
1082 char * sep;
1083 char   cmd[1024] = {0}, rcmd[1024] = {0};
1084 int    proxy_port = 22;
1085 int    use_socat = 0;
1086 int r;
1087 int socks[2];
1088
1089 if ( host == NULL )
1090  return -1;
1091
1092 if ( *host == '/' )
1093  use_socat = 1;
1094
1095 if ( mode == MODE_LISTEN )
1096  return -1;
1097
1098 if ( proxy_addr == NULL )
1099  return -1;
1100
1101 if ( opts != NULL ) {
1102  if ( !strcmp(opts, "socat") ) {
1103   use_socat = 1;
1104  } else if ( !strcmp(opts, "netcat") ) {
1105   use_socat = 0;
1106  } else {
1107   return -1;
1108  }
1109 }
1110
1111 ROAR_DBG("roar_socket_open_ssh(*): proxy_addr='%s'", proxy_addr);
1112
1113 if ( (sep = strstr(proxy_addr, "@")) != NULL )
1114  proxy_addr = sep+1;
1115
1116 if ( (sep = strstr(proxy_addr, ":")) != NULL ) {
1117  *sep = 0;
1118  proxy_port = atoi(sep+1);
1119 }
1120
1121
1122 if ( !strcmp(host, "+fork") ) {
1123  strncpy(rcmd, "roard --no-listen --client-fh 0", 32);
1124 } else {
1125  if ( use_socat ) {
1126   if ( *host == '/' ) {
1127    snprintf(rcmd, 1023, "socat stdio unix-connect:\"%s\"", host);
1128   } else {
1129    snprintf(rcmd, 1023, "socat stdio tcp:\"%s\":%i", host, port);
1130   }
1131  } else {
1132   snprintf(rcmd, 1023, "$(which netcat nc 2> /dev/null | grep -v \" \" | head -n 1) \"%s\" %i", host, port);
1133  }
1134
1135  rcmd[1023] = 0;
1136 }
1137
1138 ROAR_DBG("roar_socket_open_ssh(*): proxy_port=%i, user='%s', proxy_addr='%s'", proxy_port, user, proxy_addr);
1139 ROAR_DBG("roar_socket_open_ssh(*): rcmd: %s", rcmd);
1140 snprintf(cmd, 1023, ROAR_HAVE_BIN_SSH " -p %i -l '%s' '%s' '%s'", proxy_port, user, proxy_addr, rcmd);
1141 cmd[1023] = 0;
1142
1143
1144// TODO: get this more portable!
1145#ifdef AF_UNIX
1146 if ( socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1 ) {
1147  return -1;
1148 }
1149#else
1150 return -1;
1151#endif
1152
1153 r = fork();
1154
1155 if ( r == -1 ) { // error!
1156  ROAR_ERR("roar_socket_open_ssh(*): Can not fork: %s", strerror(errno));
1157  close(socks[0]);
1158  close(socks[1]);
1159  return -1;
1160 } else if ( r == 0 ) { // we are the child
1161  close(socks[0]);
1162
1163  close(ROAR_STDIN ); // we do not want roard to have any standard input
1164  close(ROAR_STDOUT); // STDOUT is also not needed, so we close it,
1165                      // but STDERR we keep open for error messages.
1166
1167  dup2(socks[1], 0);
1168  dup2(socks[1], 1);
1169
1170  execlp("sh", "sh", "-c", cmd, (char*)NULL);
1171
1172  // we are still alive?
1173  ROAR_ERR("roar_socket_open_ssh(*): alive after exec(), that's bad!");
1174  _exit(1);
1175 } else { // we are the parent
1176  close(socks[1]);
1177  return socks[0];
1178 }
1179 return -1;
1180}
1181#endif
1182
1183#endif // ROAR_SUPPORT_PROXY
1184
1185//ll
Note: See TracBrowser for help on using the repository browser.