source: roaraudio/libroar/socket.c @ 4692:834121094e10

Last change on this file since 4692:834121094e10 was 4692:834121094e10, checked in by phi, 13 years ago

some more debug lions

File size: 27.9 KB
Line 
1//socket.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2010
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, &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#endif
515#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
516 struct hostent     * he;
517#endif
518 //unsigned int host_div = 0;
519#ifdef ROAR_TARGET_WIN32
520 int PASCAL (*mode_func)(SOCKET,const struct sockaddr*,int) = connect; // default is to connect
521#else
522 int (*mode_func)(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen) = connect; // default is to connect
523#endif
524#ifdef ROAR_HAVE_LIBDNET
525#define _NEED_OBJ
526#endif
527#ifdef _NEED_OBJ
528 char obj[80];
529 char * del;
530#endif
531
532 ROAR_DBG("roar_socket_open(mode=%i, type=%i, host='%s', port=%i) = ?", mode, type, host, port);
533
534 if ( mode == MODE_LISTEN )
535  mode_func = bind;
536
537 if ( type == ROAR_SOCKET_TYPE_UNKNOWN ) {
538  type = ROAR_SOCKET_TYPE_INET;
539  if ( *host == '/' ) {
540   type = ROAR_SOCKET_TYPE_UNIX;
541  } else if ( strcmp(host, "+fork") == 0 ) {
542   type = ROAR_SOCKET_TYPE_FORK;
543  } else if ( strcmp(host, "+abstract") == 0 ) {
544   type = ROAR_SOCKET_TYPE_UNIX;
545#ifdef ROAR_HAVE_UNIX
546   abstract = 1;
547#endif
548  } else if ( strstr(host, "::") != NULL ) {
549   type = ROAR_SOCKET_TYPE_DECNET;
550  } else if ( host[strlen(host)-1] == ')' ) {
551   type = ROAR_SOCKET_TYPE_IPX;
552  }
553 }
554
555
556 ROAR_DBG("roar_socket_open(mode=%i, type=%i, host='%s', port=%i) = ?", mode, type, host, port);
557
558 ROAR_DBG("roar_socket_open(*): type=%s, host='%s', port=%i",
559             type == ROAR_SOCKET_TYPE_UNIX ? "UNIX" : "???", host, port);
560
561 if ( type == ROAR_SOCKET_TYPE_DECNET ) {
562#ifdef ROAR_HAVE_LIBDNET
563   ROAR_DBG("roar_socket_open(*): hostname for DECnet: host(%p)=%s", host, host);
564   del = strstr(host, "::");
565   ROAR_DBG("roar_socket_open(*): hostname for DECnet: del(%p)=%s", del, del);
566
567   if ( del == NULL ) {
568    ROAR_WARN("roar_socket_open(*): invalid hostname for DECnet: %s", host);
569    return -1;
570   }
571
572   *del = 0;
573
574   if ( *(del+2) == '#' ) { // assume we have node::#num
575    port = atoi(del+2);
576   }
577
578   if ( port ) {
579    snprintf(obj, 7, "%i", port); // no need for snprintf() as dec(port) is smaller than obj[]
580   } else {
581    *obj = 0;
582    strncat(obj, del+2, 79);
583   }
584
585  if ( mode == MODE_LISTEN ) {
586   fh = roar_socket_listen_decnet(obj, port);
587   *del = ':';
588   return fh;
589//   return -1; // listen sockets on DECnet are not supportet at the moment
590  } else {
591   // There is nothing wrong in this case to use dnet_conn() so we do.
592   fh = dnet_conn(host, obj, SOCK_STREAM, 0 ,0 ,0 , 0);
593   *del = ':';
594   return fh;
595  }
596#else
597  return -1; // no decnet support
598#endif
599 }
600
601#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
602 memset(&socket_addr,    0, sizeof(socket_addr));
603 memset(&he,             0, sizeof(he));               // FIXME: we have a valid pointer in here????
604#endif
605
606
607 if ( type == ROAR_SOCKET_TYPE_INET || type == ROAR_SOCKET_TYPE_INET6 ) {
608#if defined(ROAR_HAVE_IPV4) || defined(ROAR_HAVE_IPV6)
609
610  ROAR_DBG("roar_socket_open(*): type=INET|INET6, host='%s', port=%i", host, port);
611
612  roar_socket_win32_init(); // we need to do this early as gethostbyname() requires this.
613
614  ROAR_DBG("roar_socket_open(*): type=INET|INET6, host='%s', port=%i", host, port);
615
616  if ( (he = gethostbyname(host)) == NULL ) {
617   ROAR_ERR("roar_socket_open(*): Can\'t resolve host name '%s'",
618                     host);
619   return -1;
620  }
621
622   ROAR_DBG("roar_socket_open(*): he=%p", he);
623
624   memcpy((struct in_addr *)&socket_addr.in.sin_addr, he->h_addr, sizeof(struct in_addr));
625
626   /* set the connect information */
627   socket_addr.in.sin_family = AF_INET;
628   socket_addr.in.sin_port   = ROAR_HOST2NET16(port);
629
630  fh = roar_socket_new_tcp();
631
632  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
633
634  if ( fh == -1 ) {
635   ROAR_ERR("roar_socket_open(*): Can\'t create TCP socket: %s", strerror(errno));
636   return -1;
637  }
638
639  ROAR_DBG("roar_socket_open(*) = ?");
640
641  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
642
643   if ( mode_func(fh, (struct sockaddr *)&socket_addr.in, sizeof(struct sockaddr_in)) == -1 ) {
644    ROAR_DBG("roar_socket_open(*): Can not connect/bind: %s", strerror(errno));
645    close(fh);
646    return -1;
647   }
648
649  ROAR_DBG("roar_socket_open(*): fh=%i", fh);
650
651  // hey! we have a socket...
652  ROAR_DBG("roar_socket_open(*) = ? // we have a socket :)");
653#else
654  ROAR_DBG("roar_socket_open(*) = -1 // no IPv4 or IPv6 support");
655  return -1;
656#endif
657 } else if ( type == ROAR_SOCKET_TYPE_UNIX ) {
658#ifdef ROAR_HAVE_UNIX
659  socket_addr.un.sun_family = AF_UNIX;
660
661  if ( abstract ) {
662   memset(socket_addr.un.sun_path, 0, sizeof(socket_addr.un.sun_path));
663   snprintf(socket_addr.un.sun_path+1, sizeof(socket_addr.un.sun_path)-1, "RoarAudio/UNIX/Abstract/%i", abstract);
664  } else {
665   strncpy(socket_addr.un.sun_path, host, sizeof(socket_addr.un.sun_path) - 1);
666  }
667
668  fh = roar_socket_new_unix();
669
670  if ( mode_func(fh, (struct sockaddr *)&socket_addr.un, sizeof(struct sockaddr_un)) == -1 ) {
671   ROAR_DBG("roar_socket_open(*): Can not connect/bind: %s", strerror(errno));
672   close(fh);
673   return -1;
674  }
675#else
676  ROAR_ERR("roar_socket_open(*): There is no UNIX Domain Socket support in win32, download a real OS.");
677  return -1;
678#endif
679 } else if ( type == ROAR_SOCKET_TYPE_IPX ) {
680#ifdef ROAR_HAVE_IPX
681  socket_addr.ipx.sipx_family = AF_IPX;
682
683  obj[0] = 0;
684
685  if ( (ret = sscanf(host, "%8x.%12s(%x)", &socket_addr.ipx.sipx_network, obj, &ipx_port)) < 2 ) {
686   return -1;
687   socket_addr.ipx.sipx_port = ipx_port;
688  } else if ( ret == 2 ) {
689   socket_addr.ipx.sipx_port = port; // Network Byte Order?
690  }
691
692  memset(socket_addr.ipx.sipx_node, 0, IPX_NODE_LEN);
693  ret = strlen(obj);
694
695  if ( ret % 2 )  // needs to be even at the moment
696   return -1;
697
698  fh = roar_socket_new_ipx();
699
700  close(fh);
701  return -1;
702#else
703  return -1;
704#endif
705 } else if ( type == ROAR_SOCKET_TYPE_FORK ) {
706  return roar_socket_open_fork(mode, host, port);
707 } else if ( type == ROAR_SOCKET_TYPE_FILE ) {
708  return roar_socket_open_file(mode, host, port);
709 } else {
710  return -1;
711 }
712
713 if ( mode == MODE_LISTEN ) {
714#if defined(ROAR_HAVE_BSDSOCKETS) || defined(ROAR_TARGET_WIN32)
715  if ( listen(fh, ROAR_SOCKET_QUEUE_LEN) == -1 ) {
716   close(fh);
717   return -1;
718  }
719#else
720  return -1;
721#endif
722 }
723
724 return fh;
725}
726
727int roar_socket_open_fork  (int mode, char * host, int port) {
728#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
729 char * daemonimage;
730 int socks[2];
731 int r;
732 char fhstr[8];
733
734 if ( mode == MODE_LISTEN )
735  return -1;
736
737 // TODO: FIXME: we should move this into the config structure.
738 daemonimage = getenv("ROAR_DAEMONIMAGE");
739
740 if ( daemonimage == NULL || *daemonimage == 0 )
741  daemonimage = "roard";
742
743 if ( socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1 ) {
744  return -1;
745 }
746
747 r = fork();
748
749 if ( r == -1 ) { // error!
750  ROAR_ERR("roar_socket_open_fork(*): Can not fork: %s", strerror(errno));
751  close(socks[0]);
752  close(socks[1]);
753  return -1;
754 } else if ( r == 0 ) { // we are the child
755  close(socks[0]);
756
757  close(ROAR_STDIN ); // we do not want roard to have any standard input
758  close(ROAR_STDOUT); // STDOUT is also not needed, so we close it,
759                      // but STDERR we keep open for error messages.
760
761  snprintf(fhstr, 7, "%i", socks[1]);
762
763  execlp(daemonimage, daemonimage, "--no-listen", "--client-fh", fhstr, (char*)NULL);
764
765  // we are still alive?
766  ROAR_ERR("roar_socket_open_fork(*): alive after exec(), that's bad!");
767  _exit(1);
768 } else { // we are the parent
769  close(socks[1]);
770  return socks[0];
771 }
772
773 return -1;
774#else
775 ROAR_ERR("roar_socket_open_fork(*): There is no UNIX Domain Socket support in win32, download a real OS.");
776 return -1;
777#endif
778}
779
780int roar_socket_open_file  (int mode, char * host, int port) {
781#ifdef ROAR_HAVE_IO_POSIX
782 int fh;
783
784 if ( mode == MODE_LISTEN )
785  return -1;
786
787 if ( (fh = open(host, O_RDONLY, 0644)) == -1 ) {
788  ROAR_ERR("roar_socket_open_file(*): Can not open file %s: %s", host, strerror(errno));
789 }
790
791 return fh;
792#else
793 return -1;
794#endif
795}
796
797// --- [ PROXY CODE ] ---
798
799#ifndef ROAR_HAVE_IO_POSIX
800#ifdef  ROAR_SUPPORT_PROXY
801#undef  ROAR_SUPPORT_PROXY
802#endif
803#endif
804
805// generic proxy code:
806
807#ifdef ROAR_SUPPORT_PROXY
808int roar_socket_open_proxy (int mode, int type, char * host, int port, char * proxy_type) {
809 int    proxy_port = -1;
810 char   proxy_host[ROAR_SOCKET_MAX_HOSTNAMELEN];
811 char * proxy_addr = NULL;
812 int    i;
813 int    fh = -1;
814 char * user = NULL, * pw = NULL, * opts = NULL;
815 char * sep;
816 int    no_fh = 0;
817 char   proxy_addr_buf[1024];
818 static struct passwd * passwd;
819 int (* code)(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) = NULL;
820
821 if ( passwd == NULL ) {
822  passwd = getpwuid(getuid());
823 }
824
825// TODO: fix this in a good way
826#ifndef ROAR_TARGET_MICROCONTROLLER
827 if ( passwd != NULL )
828  user = passwd->pw_name;
829#endif
830
831 if ( user == NULL )
832  user = getenv("USER");
833
834 // TODO: change this so we support listen() proxys (ssh -R)
835 if ( mode != MODE_CONNECT )
836  return -1;
837
838 if ( !strncmp(proxy_type, "socks", 5) ) {
839  proxy_addr = getenv("socks_proxy");
840
841  proxy_port = 9050; // TOR's default port
842 } else if ( !strcmp(proxy_type, "http") || !strcmp(proxy_type, "https") ) {
843  proxy_port = 8080;
844
845  if ( (proxy_addr = getenv("http_proxy")) == NULL )
846   proxy_addr = getenv("https_proxy");
847
848  if ( proxy_addr == NULL )
849   return -1;
850
851  if ( !strncmp(proxy_addr, "http://", 7) )
852   proxy_addr += 7;
853 } else if ( !strncmp(proxy_type, "ssh", 3) ) {
854  proxy_port = 22;
855  proxy_addr = getenv("ssh_proxy");
856  no_fh      = 1;
857 }
858
859 proxy_addr_buf[1023] = 0;
860 strncpy(proxy_addr_buf, proxy_addr, 1023);
861 proxy_addr = proxy_addr_buf;
862
863 if ( (sep = strstr(proxy_type, "/")) != NULL )
864  opts = sep+1;
865
866 if ( proxy_addr == NULL )
867  return -1;
868
869 if ( (sep = strstr(proxy_addr, "@")) != NULL ) {
870  *sep = 0;
871  user = proxy_addr;
872  proxy_addr = sep+1;
873
874  if ( (sep = strstr(user, ":")) != NULL ) {
875   *sep = 0;
876   pw = sep+1;
877  }
878 }
879
880 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);
881
882 for (i = 0; proxy_addr[i] != 0 && proxy_addr[i] != ':' && i < (ROAR_SOCKET_MAX_HOSTNAMELEN - 1); i++)
883  proxy_host[i] = proxy_addr[i];
884 proxy_host[i] = 0;
885
886 if ( i == 0 ) // no hostname found
887  return -1;
888
889 if ( proxy_addr[i] == ':' )
890  proxy_port = atoi(&proxy_addr[i+1]);
891
892 if ( ! no_fh ) {
893  if ( (fh = roar_socket_open(mode, type, proxy_host, proxy_port)) == -1) {
894   return -1;
895  }
896 }
897
898 if ( !strcmp(proxy_type, "socks4a") ) { // for TOR, the only supported type at the moment
899  code = roar_socket_open_socks4a;
900 } else if ( !strcmp(proxy_type, "socks4d") ) { // DECnet
901  code = roar_socket_open_socks4d;
902 } else if ( !strcmp(proxy_type, "socks4") ) { // good old SOCKS4
903  code = roar_socket_open_socks4;
904 } else if ( !strcmp(proxy_type, "http") ) { // HTTP CONNECT
905  code = roar_socket_open_http;
906 } else if ( !strncmp(proxy_type, "ssh", 3) ) { // SSH...
907#ifdef ROAR_HAVE_BIN_SSH
908  code = roar_socket_open_ssh;
909#else
910  ROAR_ERR("roar_socket_open_proxy(*): No SSH support compiled in");
911#endif
912 } else {
913  return -1; // unknown type
914 }
915
916 if ( code != NULL ) {
917  if ( no_fh ) {
918   fh = code(mode, fh, host, port, user, pw, opts);
919  } else {
920   if ( code(mode, fh, host, port, user, pw, opts) == -1 ) {
921    close(fh);
922    return -1;
923   }
924  }
925
926  return fh;
927 }
928
929 close(fh);
930 return -1;
931}
932
933// protocoll dependet proxy code:
934
935int roar_socket_open_socks4 (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
936#ifndef ROAR_TARGET_MICROCONTROLLER
937 struct hostent     * he;
938
939 if ( (he = gethostbyname(host)) == NULL ) {
940  ROAR_ERR("roar_socket_open_socks4(*): Can\'t resolve host name '%s'", host);
941  return -1;
942 }
943
944 return roar_socket_open_socks4x(mode, fh, he->h_addr, port, NULL, 0, user);
945#else
946 return -1;
947#endif
948}
949
950int roar_socket_open_socks4a(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
951 return roar_socket_open_socks4x(mode, fh, "\0\0\0\1", port, host, strlen(host)+1, user);
952}
953
954int roar_socket_open_socks4d(int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
955 size_t len = strlen(host)+1;
956 char * dp;
957
958 if ( port == 0 ) {
959  if ( (dp = strstr(host, "::")) == NULL )
960   return -1;
961
962  len--;
963  *dp = 0;
964  memmove(dp+1, dp+2, len - (dp-host) - 1);
965 }
966
967 return roar_socket_open_socks4x(mode, fh, "\0\2\0\0", port, host, len, user);
968}
969
970int roar_socket_open_socks4x(int mode, int fh, char host[4], int port, char * app, size_t app_len, char * user) {
971 char buf[9];
972 int len;
973
974 buf[0] = 0x04;
975 buf[1] = mode == MODE_CONNECT ? 0x01 : 0x02;
976 *((uint16_t*)&buf[2]) = htons(port);
977 memcpy(buf+4, host, 4);
978
979 if ( user == NULL ) {
980  buf[8] = 0x00;
981  len = 9;
982 } else {
983  len = 8;
984 }
985
986 if ( write(fh, buf, len) != len )
987  return -1;
988
989 if ( user != NULL ) {
990  len = strlen(user) + 1;
991  if ( write(fh, user, len) != len )
992   return -1;
993 }
994
995 if ( app_len > 0 )
996  if ( write(fh, app, app_len) != app_len )
997   return -1;
998
999 if ( read(fh, buf, 8) != 8 )
1000  return -1;
1001
1002 if ( buf[1] != 0x5a )
1003  return -1;
1004
1005 return 0;
1006}
1007
1008int roar_socket_open_http   (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
1009 char buf[1024];
1010 int len;
1011
1012 if ( port == 0 || host == NULL )
1013  return -1;
1014
1015 if ( *host == '/' ) // AF_UNIX
1016  return -1;
1017
1018 if ( (len = snprintf(buf, 1024, "CONNECT %s:%i HTTP/1.0\r\nUser-Agent: libroar\r\n\r\n", host, port)) == -1 )
1019  return -1;
1020
1021 if ( write(fh, buf, len) != len )
1022  return -1;
1023
1024 while ( (len = read(fh, buf, 1024)) ) {
1025  if ( len == 1024 ) { // overlong lion
1026   return -1;
1027  } else if ( len == 2 && buf[0] == '\r' && buf[1] == '\n' ) {
1028   break;
1029  } else if ( len == 1 && (buf[0] == '\r' || buf[0] == '\n') ) { // bad proxy or devel trying to debug ;)
1030   break;
1031  } else if ( len >= 4 && buf[len-4] == '\r' && buf[len-3] == '\n' && buf[len-2] == '\r' && buf[len-1] == '\n' ) {
1032   break;
1033  }
1034 }
1035
1036 return 0;
1037}
1038
1039
1040#ifdef ROAR_HAVE_BIN_SSH
1041int roar_socket_open_ssh    (int mode, int fh, char * host, int port, char * user, char * pw, char * opts) {
1042 char * proxy_addr = getenv("ssh_proxy");
1043 char * sep;
1044 char   cmd[1024] = {0}, rcmd[1024] = {0};
1045 int    proxy_port = 22;
1046 int    use_socat = 0;
1047 int r;
1048 int socks[2];
1049
1050 if ( host == NULL )
1051  return -1;
1052
1053 if ( *host == '/' )
1054  use_socat = 1;
1055
1056 if ( mode == MODE_LISTEN )
1057  return -1;
1058
1059 if ( proxy_addr == NULL )
1060  return -1;
1061
1062 if ( opts != NULL ) {
1063  if ( !strcmp(opts, "socat") ) {
1064   use_socat = 1;
1065  } else if ( !strcmp(opts, "netcat") ) {
1066   use_socat = 0;
1067  } else {
1068   return -1;
1069  }
1070 }
1071
1072 ROAR_DBG("roar_socket_open_ssh(*): proxy_addr='%s'", proxy_addr);
1073
1074 if ( (sep = strstr(proxy_addr, "@")) != NULL )
1075  proxy_addr = sep+1;
1076
1077 if ( (sep = strstr(proxy_addr, ":")) != NULL ) {
1078  *sep = 0;
1079  proxy_port = atoi(sep+1);
1080 }
1081
1082
1083 if ( !strcmp(host, "+fork") ) {
1084  strncpy(rcmd, "roard --no-listen --client-fh 0", 32);
1085 } else {
1086  if ( use_socat ) {
1087   if ( *host == '/' ) {
1088    snprintf(rcmd, 1023, "socat stdio unix-connect:\"%s\"", host);
1089   } else {
1090    snprintf(rcmd, 1023, "socat stdio tcp:\"%s\":%i", host, port);
1091   }
1092  } else {
1093   snprintf(rcmd, 1023, "$(which netcat nc 2> /dev/null | grep -v \" \" | head -n 1) \"%s\" %i", host, port);
1094  }
1095
1096  rcmd[1023] = 0;
1097 }
1098
1099 ROAR_DBG("roar_socket_open_ssh(*): proxy_port=%i, user='%s', proxy_addr='%s'", proxy_port, user, proxy_addr);
1100 ROAR_DBG("roar_socket_open_ssh(*): rcmd: %s", rcmd);
1101 snprintf(cmd, 1023, ROAR_HAVE_BIN_SSH " -p %i -l '%s' '%s' '%s'", proxy_port, user, proxy_addr, rcmd);
1102 cmd[1023] = 0;
1103
1104
1105// TODO: get this more portable!
1106#ifdef AF_UNIX
1107 if ( socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1 ) {
1108  return -1;
1109 }
1110#else
1111 return -1;
1112#endif
1113
1114 r = fork();
1115
1116 if ( r == -1 ) { // error!
1117  ROAR_ERR("roar_socket_open_ssh(*): Can not fork: %s", strerror(errno));
1118  close(socks[0]);
1119  close(socks[1]);
1120  return -1;
1121 } else if ( r == 0 ) { // we are the child
1122  close(socks[0]);
1123
1124  close(ROAR_STDIN ); // we do not want roard to have any standard input
1125  close(ROAR_STDOUT); // STDOUT is also not needed, so we close it,
1126                      // but STDERR we keep open for error messages.
1127
1128  dup2(socks[1], 0);
1129  dup2(socks[1], 1);
1130
1131  execlp("sh", "sh", "-c", cmd, (char*)NULL);
1132
1133  // we are still alive?
1134  ROAR_ERR("roar_socket_open_ssh(*): alive after exec(), that's bad!");
1135  _exit(1);
1136 } else { // we are the parent
1137  close(socks[1]);
1138  return socks[0];
1139 }
1140 return -1;
1141}
1142#endif
1143
1144#endif // ROAR_SUPPORT_PROXY
1145
1146//ll
Note: See TracBrowser for help on using the repository browser.