source: roaraudio/libroar/basic.c @ 5468:8362cf6b111b

Last change on this file since 5468:8362cf6b111b was 5468:8362cf6b111b, checked in by phi, 12 years ago

do not allow a seq num of zero

File size: 18.5 KB
RevLine 
[0]1//basic.c:
2
[690]3/*
[5381]4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2012
[690]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
[3517]21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
[690]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
[0]36#include "libroar.h"
37
[5369]38static int _start_server(struct roar_connection * con, const char * server, int type, int flags, uint_least32_t timeout) {
39#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
40 enum {
41  NORMAL = 0,
42  SYSTEM = 1
43 } mode = NORMAL;
44 const char * daemonimage = NULL;
45 int socks[2];
46 int r;
47 char fhstr[12];
48
49 if ( !strncmp(server, "+fork=", 6) ) {
50  server += 6;
51  if ( server[0] == 0 ) {
52   // no special case, we just ignore it.
53  } else if ( server[0] == 'd' && server[1] == ':' ) {
54   server += 2;
55   daemonimage = server;
56  } else if ( server[0] == '!' ) {
57   server += 1;
58   daemonimage = server;
59   mode = SYSTEM;
60  } else {
61   roar_err_set(ROAR_ERROR_ILLSEQ);
62   return -1;
63  }
64 }
65
66 if ( daemonimage == NULL )
[5373]67  daemonimage = roar_libroar_get_config()->daemonimage;
68
69 // we keep this step to be compatible with older versions.
70 if ( daemonimage == NULL || *daemonimage == 0 ) {
[5369]71  daemonimage = getenv("ROAR_DAEMONIMAGE");
[5373]72  if ( daemonimage != NULL ) {
73   ROAR_WARN("_start_server(*): Usage of $ROAR_DAEMONIMAGE is obsolete. Use ROAR_OPTIONS=daemonimage:...");
74  }
75 }
[5369]76
77 if ( daemonimage == NULL || *daemonimage == 0 )
78  daemonimage = "roard";
79
80 if ( socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1 ) {
81  roar_err_from_errno();
82  return -1;
83 }
84
[5373]85 r = roar_fork(NULL);
[5369]86
87 if ( r == -1 ) { // error!
[5373]88  ROAR_ERR("_start_server(*): Can not fork: %s", roar_error2str(roar_error));
[5369]89  close(socks[0]);
90  close(socks[1]);
91  return -1;
92 } else if ( r == 0 ) { // we are the child
93  close(socks[0]);
94
95  close(ROAR_STDIN ); // we do not want roard to have any standard input
96  close(ROAR_STDOUT); // STDOUT is also not needed, so we close it,
97                      // but STDERR we keep open for error messages.
98
99  snprintf(fhstr, sizeof(fhstr), "%i", socks[1]);
100
101  switch (mode) {
102   case NORMAL:
103     execlp(daemonimage, daemonimage, "--no-listen", "--client-fh", fhstr, (_LIBROAR_GOOD_CAST char*)NULL);
104    break;
105   case SYSTEM:
106     dup2(socks[1], ROAR_STDIN );
107     dup2(socks[1], ROAR_STDOUT);
108     execl("/bin/sh", "/bin/sh", "-c", daemonimage, (_LIBROAR_GOOD_CAST char*)NULL);
109     execlp("sh", "sh", "-c", daemonimage, (_LIBROAR_GOOD_CAST char*)NULL);
110    break;
111  }
112
113  // we are still alive?
[5373]114  ROAR_ERR("_start_server(*): alive after exec(), that's bad!");
[5369]115  _exit(1);
116 } else { // we are the parent
117  close(socks[1]);
118  if ( roar_vio_open_fh_socket(con->viocon, socks[0]) == -1 ) {
119   close(socks[0]);
120   return -1;
121  } else {
122   con->flags |= ROAR_CON_FLAGS_VIO;
123  }
124  return 0;
125 }
126
127 return -1;
128#else
[5373]129 ROAR_ERR("_start_server(*): There is no UNIX Domain Socket support in win32, download a real OS.");
[5369]130 return -1;
131#endif
132}
133
[5373]134static int _connect_internal(struct roar_connection * con, const char * server, int type, int flags, uint_least32_t timeout) {
135 struct roar_libroar_config * config = roar_libroar_get_config();
136 struct roar_vio_calls * vio;
137
138 if ( config->connect_internal != NULL ) {
139  vio = config->connect_internal(con, server, type, flags, timeout);
140  if ( vio == NULL )
141   return -1;
142
143  con->viocon = vio;
144  con->flags |= ROAR_CON_FLAGS_VIO;
145
146  return 0;
147 }
148
149 roar_err_set(ROAR_ERROR_BADHOST);
150 return -1;
151}
152
[5368]153static int _connect_server(struct roar_connection * con, const char * server, int type, int flags, uint_least32_t timeout) {
154#if defined(ROAR_HAVE_STAT) && defined(ROAR_HAVE_H_SYS_STAT)
155 struct stat sockstat;
156#endif
157 const char * obj = NULL;
158 char user_sock[128];
159 int is_decnet = 0;
160 int port = 0;
161 int i = 0;
162 int fh = -1;
163 int err;
164
165 if ( con == NULL || server == NULL ) {
166  roar_err_set(ROAR_ERROR_FAULT);
167  return -1;
168 }
169
170 if ( !strcmp(server, "+invalid") ) {
171  roar_err_set(ROAR_ERROR_CANCELED);
172  return -1;
173 } else if ( !strncmp(server, "+dstr=", 6) ) {
174  if ( roar_vio_open_dstr_simple(con->viocon, server+6, ROAR_VIOF_READWRITE) == -1 )
175   return -1;
176  con->flags |= ROAR_CON_FLAGS_VIO;
177  return 0;
[5369]178 } else if ( !strcmp(server, "+fork") || !strncmp(server, "+fork=", 6) ) {
179  return _start_server(con, server, type, flags, timeout);
[5373]180 } else if ( !strcmp(server, "+internal") || !strncmp(server, "+internal=", 10) ) {
181  return _connect_internal(con, server, type, flags, timeout);
[5368]182 }
183
184 strncpy(user_sock, server, sizeof(user_sock)-1);
185 user_sock[sizeof(user_sock)-1] = 0;
186
187
188 if ( *user_sock != '/' ) { // don't test AF_UNIX sockets for ports
189  for (i = 0; user_sock[i] != 0; i++) {
190   if ( user_sock[i] == ':' ) {
191    if ( user_sock[i+1] == ':' ) { // DECnet, leave unchanged
192     is_decnet = 1;
193     obj = &user_sock[i+2];
194     break;
195    }
196
197    port = atoi(&(user_sock[i+1]));
198    user_sock[i] = 0;
199    break;
200   }
201  }
202 }
203
204 if ( is_decnet ) {
205  if ( *user_sock == ':' ) {
206   if ( roar_socket_get_local_nodename() != NULL ) {
207    strncpy(user_sock, roar_socket_get_local_nodename(), sizeof(user_sock)-1);
208    user_sock[sizeof(user_sock)-1] = 0;
209    roar_mm_strlcat(user_sock, server, sizeof(user_sock)-1);
210    user_sock[sizeof(user_sock)-1] = 0;
211    obj  = strstr(user_sock, "::");
212    obj += 2;
213   }
214  }
215
216  if ( *obj == 0 ) {
217#ifdef DN_MAXOBJL
218   roar_mm_strlcat(user_sock, ROAR_DEFAULT_OBJECT, sizeof(user_sock)-1);
219   user_sock[sizeof(user_sock)-1] = 0;
220#else
221   ROAR_ERR("roar_connect_raw(*): size of DECnet object unknown.");
222#endif
223  }
224   ROAR_DBG("roar_connect_raw(*): user_sock='%s'", user_sock);
225 }
226
227 if ( port || is_decnet ) {
[5375]228  fh = roar_socket_connect(type, user_sock, port);
[5368]229  // restore the original string
230  user_sock[i] = ':';
231 } else {
232#if defined(ROAR_HAVE_STAT) && defined(ROAR_HAVE_H_SYS_STAT)
233  if ( user_sock[0] == '/' ) {
234   if ( stat(user_sock, &sockstat) == 0 ) {
235    if ( S_ISCHR(sockstat.st_mode) ) {
[5406]236#ifdef O_NOCTTY
[5428]237     fh = open(user_sock, O_RDWR|O_NOCTTY, 0666);
[5406]238#else
[5428]239     fh = open(user_sock, O_RDWR, 0666);
[5406]240#endif
[5368]241    }
242   }
243  }
244#endif
[5428]245  if ( fh == -1 )
246   fh = roar_socket_connect(type, user_sock, ROAR_DEFAULT_PORT);
[5368]247 }
248
249 if ( fh == -1 )
250  return -1;
251
252 if ( roar_vio_open_fh_socket(con->viocon, fh) == -1 ) {
253  err = roar_error;
254#ifdef ROAR_TARGET_WIN32
255  closesocket(fh);
256#else
257  close(fh);
258#endif
259  roar_error = err;
260  return -1;
261 } else {
262  con->flags |= ROAR_CON_FLAGS_VIO;
263 }
264
265 roar_err_set(ROAR_ERROR_NONE);
266 return 0;
267}
268
269static int roar_connect_raw (struct roar_connection * con, const char * server, int flags, uint_least32_t timeout) {
[4780]270#ifdef ROAR_HAVE_LIBSLP
[4653]271 struct roar_libroar_config * config = roar_libroar_get_config();
[4780]272#endif
[5393]273#if defined(ROAR_HAVE_UNIX) || !defined(ROAR_TARGET_MICROCONTROLLER)
[5114]274 char user_sock[128];
[0]275 char * roar_server;
[5393]276#endif
277#if defined(ROAR_HAVE_LIBSLP) || !defined(ROAR_TARGET_MICROCONTROLLER)
[701]278 int i = 0;
[5393]279#endif
[1475]280#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
[1026]281 struct passwd * pwd;
[1393]282#endif
[828]283#ifdef ROAR_HAVE_LIBDNET
284 struct stat decnet_stat;
285#endif
[3372]286#ifdef ROAR_HAVE_LIBX11
287 struct roar_x11_connection * x11con;
288#endif
[4945]289#ifdef ROAR_HAVE_LIBSLP
[4806]290 struct roar_server * list;
291 int workarounds_store;
[4945]292#endif
[0]293
[4873]294 roar_err_set(ROAR_ERROR_UNKNOWN);
[807]295
[4806]296 if ( timeout != 0 ) {
[4873]297  roar_err_set(ROAR_ERROR_INVAL);
[4806]298  return -1;
299 }
300
301 if ( flags & ROAR_ENUM_FLAG_HARDNONBLOCK )
302  flags |= ROAR_ENUM_FLAG_NONBLOCK;
303
304
[5368]305 if ( server == NULL || *server == 0 )
[2567]306  server = roar_libroar_get_server();
307
[5368]308 if ( server == NULL || *server == 0 )
309  server = getenv("ROAR_SERVER");
[0]310
[3372]311#ifdef ROAR_HAVE_LIBX11
[5368]312 if ( server == NULL || *server == 0 ) {
[3372]313  if ( (x11con = roar_x11_connect(NULL)) != NULL ) {
314   server = roar_x11_get_prop(x11con, "ROAR_SERVER");
315   roar_x11_disconnect(x11con);
316  }
317 }
318#endif
319
[1436]320#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
[5368]321 if ( (server == NULL || *server == 0) && (i = readlink("/etc/roarserver", user_sock, sizeof(user_sock)-1)) != -1 ) {
[448]322   user_sock[i] = 0;
323   server = user_sock;
324 }
[1093]325#endif
[448]326
[3077]327 if ( server != NULL && !strcasecmp(server, "+slp") ) {
[3076]328  server = roar_slp_find_roard(0);
329  if ( server == NULL ) {
330   return -1;
331  }
332 }
333
[61]334 if ( server == NULL || *server == 0 ) {
[0]335  /* connect via defaults */
336
[1764]337#ifdef ROAR_HAVE_UNIX
[1436]338#ifndef ROAR_TARGET_MICROCONTROLLER
[1026]339  roar_server = getenv("HOME");
[1435]340#else
341  roar_server = NULL;
342#endif
[1026]343
344  if ( roar_server == NULL ) {
[1436]345#if !defined(ROAR_TARGET_WIN32) && !defined(ROAR_TARGET_MICROCONTROLLER)
[1026]346   if ( (pwd = getpwuid(getuid())) == NULL ) {
347    roar_server = "/NX-HOME-DIR";
348   } else {
349    roar_server = pwd->pw_dir;
350   }
[1078]351#else
352   roar_server = "/WIN32-SUCKS";
353#endif
[1026]354  }
355
[5114]356  snprintf(user_sock, sizeof(user_sock)-1, "%s/%s", roar_server, ROAR_DEFAULT_SOCK_USER);
357  user_sock[sizeof(user_sock)-1] = 0;
[0]358
[5368]359  if ( _connect_server(con, user_sock, ROAR_SOCKET_TYPE_UNIX, flags, timeout) == 0 )
360   return 0;
[0]361
[5368]362  if ( _connect_server(con, ROAR_DEFAULT_SOCK_GLOBAL, ROAR_SOCKET_TYPE_UNIX, flags, timeout) == 0 )
363   return 0;
[1764]364#endif
[237]365
[5368]366  if ( _connect_server(con, ROAR_DEFAULT_HOSTPORT, ROAR_SOCKET_TYPE_TCP, flags, timeout) == 0 )
367   return 0;
[0]368
[828]369#ifdef ROAR_HAVE_LIBDNET
370  if ( stat(ROAR_PROC_NET_DECNET, &decnet_stat) == 0 ) {
371   if ( roar_socket_get_local_nodename() ) {
372    snprintf(user_sock, 79, "%s::%s", roar_socket_get_local_nodename(), ROAR_DEFAULT_OBJECT);
[5368]373    if ( _connect_server(con, user_sock, ROAR_SOCKET_TYPE_DECNET, flags, timeout) == 0 )
374     return 0;
[828]375   }
[522]376  }
[828]377#endif
[2007]378
[5375]379  if ( _connect_server(con, "+abstract", ROAR_SOCKET_TYPE_UNKNOWN, flags, timeout) == 0 )
[5368]380   return 0;
[4109]381
[2007]382#ifdef ROAR_HAVE_LIBSLP
[4806]383 if ( !(config->workaround.workarounds & ROAR_LIBROAR_CONFIG_WAS_NO_SLP) &&
[5373]384      !(flags & ROAR_ENUM_FLAG_NONBLOCK) &&
385      !(flags & ROAR_ENUM_FLAG_LOCALONLY)
[4806]386    ) {
387  if ( (server = roar_slp_find_roard(0)) != NULL ) {
[5375]388   if ( _connect_server(con, server, ROAR_SOCKET_TYPE_UNKNOWN, 0, 0) == 0 )
[5368]389    return 0;
[2014]390
[4806]391   /* in case we can not connect to the server given this may be a cache problem,
392      we do a new lookup with the cache disabled in this case                     */
[5237]393   ROAR_WARN("roar_connect_raw(*): Can not connect to SLP located server, disabling cache");
[4806]394   if ( (server = roar_slp_find_roard(1)) != NULL )
[5375]395    if ( _connect_server(con, server, ROAR_SOCKET_TYPE_UNKNOWN, 0, 0) == 0 )
[5368]396     return 0;
[4806]397  }
398 }
399
400 workarounds_store = config->workaround.workarounds;
401 config->workaround.workarounds |= ROAR_LIBROAR_CONFIG_WAS_NO_SLP;
402 list = roar_enum_servers(flags, -1, -1);
403 config->workaround.workarounds = workarounds_store;
404 if ( list != NULL ) {
405  for (i = 0; list[i].server != NULL; i++) {
[5375]406   if ( _connect_server(con, list[i].server, ROAR_SOCKET_TYPE_UNKNOWN, 0, 0) == 0 ) {
[4806]407    roar_enum_servers_free(list);
[5368]408    return 0;
[4806]409   }
410  }
411  roar_enum_servers_free(list);
[4653]412 }
[2007]413#endif
[522]414
[2014]415 return -1;
416
[0]417 } else {
418  /* connect via (char*)server */
[5375]419  if ( _connect_server(con, server, ROAR_SOCKET_TYPE_UNKNOWN, flags, timeout) != 0 )
[5369]420   return -1;
421  return 0;
[0]422 }
423
[5368]424 roar_err_set(ROAR_ERROR_NODEV);
425 ROAR_DBG("roar_connect_raw(*) = -1 // error=NODEV");
426 return -1;
[0]427}
428
[5237]429int roar_connect     (struct roar_connection * con, const char * server, int flags, uint_least32_t timeout) {
[5373]430 struct roar_libroar_config * config = roar_libroar_get_config();
431
[1315]432 if ( con == NULL ) {
[4873]433  roar_err_set(ROAR_ERROR_FAULT);
[1315]434  return -1;
435 }
436
[5368]437 if ( roar_connect_none(con) == -1 )
[0]438  return -1;
439
[5368]440 roar_err_set(ROAR_ERROR_UNKNOWN);
[5373]441 if ( roar_connect_raw(con, server, flags | config->serverflags, timeout) == -1 )
[5296]442  return -1;
443
[5373]444 // TODO: this should be moved to be within _connect_server() so it also stores server names of auto located servers.
[5296]445 if ( server != NULL ) {
446  con->server_name = roar_mm_strdup(server);
447 }
448
449 return 0;
[1315]450}
451
[5365]452int roar_connect_none (struct roar_connection * con) {
[5465]453 struct roar_libroar_config * config = roar_libroar_get_config();
454
[5365]455 if ( con == NULL ) {
[4873]456  roar_err_set(ROAR_ERROR_INVAL);
[1315]457  return -1;
458 }
459
460 memset(con, 0, sizeof(struct roar_connection));
[5296]461 con->refc        = 1;
[5467]462 con->flags       = ROAR_CON_FLAGS_ISCLIENT;
[5465]463 con->version     = _ROAR_MESSAGE_VERSION;
[5232]464 con->cb_userdata = NULL;
465 con->cb          = NULL;
[5296]466 con->server_stds = NULL;
467 con->server_name = NULL;
[5232]468
469 roar_err_init(&(con->errorframe));
[1315]470
[5296]471 con->viocon = &(con->viocon_store);
472
[5365]473// con->flags |= ROAR_CON_FLAGS_VIO;
474
[5465]475 if ( config->protocolversion != -1 )
476  roar_set_connection_version(con, config->protocolversion);
477
[5365]478 roar_err_set(ROAR_ERROR_NONE);
479 return 0;
480}
481
482int roar_connect_vio (struct roar_connection * con, struct roar_vio_calls * vio) {
483 if ( con == NULL || vio == NULL ) {
484  roar_err_set(ROAR_ERROR_INVAL);
485  return -1;
486 }
487
488 if ( roar_connect_none(con) == -1 )
489  return -1;
490
491 con->viocon = vio;
492 con->flags |= ROAR_CON_FLAGS_VIO;
493
494 return -1;
495}
496
497int roar_connect_fh (struct roar_connection * con, int fh) {
498
499 if ( con == NULL || fh == -1 ) {
500  roar_err_set(ROAR_ERROR_INVAL);
501  return -1;
502 }
503
504 if ( roar_connect_none(con) == -1 )
505  return -1;
506
507 // specal hack to set an ilegal value used internaly in libroar:
508 if ( fh == -2 )
509  fh = -1;
510
[5296]511 if ( roar_vio_open_fh_socket(con->viocon, fh) != -1 ) {
[3869]512  con->flags |= ROAR_CON_FLAGS_VIO;
[5231]513 }
[1315]514
[4873]515 roar_err_set(ROAR_ERROR_NONE);
[0]516 return 0;
517}
518
[1660]519int roar_get_connection_fh (struct roar_connection * con) {
[5231]520 int fh;
521
522 ROAR_DBG("roar_get_connection_fh(con=%p) = ?", con);
523
[3869]524 roar_debug_warn_sysio("roar_get_connection_fh", "roar_get_connection_vio2", NULL);
[2809]525
[2043]526 if ( con == NULL )
527  return -1;
528
[5231]529 ROAR_DBG("roar_get_connection_fh(con=%p) = ?", con);
530
[5296]531 if ( roar_vio_ctl(con->viocon, ROAR_VIO_CTL_GET_FH, &fh) == -1 )
[3869]532  return -1;
533
[5231]534 ROAR_DBG("roar_get_connection_fh(con=%p) = %i", con, fh);
[3869]535
[5231]536 return fh;
[2043]537}
538
[3869]539struct roar_vio_calls * roar_get_connection_vio2 (struct roar_connection * con) {
540 if ( con == NULL )
541  return NULL;
542
543 if ( con->flags & ROAR_CON_FLAGS_VIO )
[5296]544  return con->viocon;
[3869]545
546// TODO: try to open the VIO.
547
548 return NULL;
549}
550
[5296]551const char * roar_get_connection_server(struct roar_connection * con) {
552 if ( con == NULL ) {
553  roar_err_set(ROAR_ERROR_FAULT);
554  return NULL;
555 }
556
557 return con->server_name;
558}
559
560int roar_connectionref(struct roar_connection * con) {
561 if ( con == NULL ) {
562  roar_err_set(ROAR_ERROR_FAULT);
563  return -1;
564 }
565
566 con->refc++;
567
568 return 0;
569}
570
571int roar_connectionunref(struct roar_connection * con) {
[3869]572 struct roar_vio_calls * vio;
[0]573 struct roar_message m;
574
[5296]575 if ( con == NULL ) {
576  roar_err_set(ROAR_ERROR_FAULT);
577  return -1;
578 }
579
580 con->refc--;
581
582 if ( con->refc )
583  return 0;
584
[3875]585 memset(&m, 0, sizeof(m));
586
[5144]587 m.datalen =  0;
588 m.stream  = -1;
589 m.pos     =  0;
[0]590 m.cmd     = ROAR_CMD_QUIT;
591
592 roar_req(con, &m, NULL);
593
[3869]594 if ( (vio = roar_get_connection_vio2(con)) != NULL ) {
595  roar_vio_close(vio);
[2809]596 }
[0]597
[5296]598 if ( con->server_stds != NULL ) {
599  roar_stds_free(con->server_stds);
600  con->server_stds = NULL;
601 }
[0]602
[5296]603 if ( con->server_name != NULL ) {
604  roar_mm_free(con->server_name);
605  con->server_name = NULL;
606 }
607
608 if ( con->flags & ROAR_CON_FLAGS_FREESELF ) {
609  roar_mm_free(con);
610 } else {
611  roar_connect_fh(con, -2);
612 }
[807]613
[0]614 return 0;
615}
616
[3913]617int roar_set_connection_callback(struct roar_connection * con,
618                                 void (*cb)(struct roar_connection * con,
619                                            struct roar_message    * mes,
[5231]620                                            void                   * data,
[3913]621                                            void                   * userdata),
622                                 void * userdata) {
[5465]623 if ( con == NULL ) {
624  roar_err_set(ROAR_ERROR_FAULT);
[3913]625  return -1;
[5465]626 }
[3913]627
628 con->cb       = cb;
[5231]629 con->cb_userdata = userdata;
[3913]630
631 return 0;
632}
633
[5465]634int roar_set_connection_version(struct roar_connection * con, int version) {
635 if ( con == NULL ) {
636  roar_err_set(ROAR_ERROR_FAULT);
637  return -1;
638 }
639
640 if ( version == -1 )
641  version = _ROAR_MESSAGE_VERSION;
642
643 if ( version < 0 ) {
644  roar_err_set(ROAR_ERROR_INVAL);
645  return -1;
646 }
647
648 con->version = version;
649
650 if ( version == 2 ) {
651  con->flags |= ROAR_CON_FLAGS_SUPPORT_V2;
652 }
653
654 return 0;
655}
656
[5467]657int16_t roar_message_genseq(struct roar_connection * con, int is_client) {
658 static int16_t store = 0;
659 int16_t ret = 0;
660
661 ret = store++;
662
[5468]663 if ( ret == 0 )
664  ret = store++;
665
[5467]666 if ( is_client == -1 ) {
667  if ( con != NULL ) {
668   is_client = con->flags & ROAR_CON_FLAGS_ISCLIENT ? 1 : 0;
669  }
670 }
671
672 if ( is_client == -1 )
673  is_client = 1;
674
675 ret |= 0x8000U;
676 if ( !is_client )
677  ret -= 0x8000U;
678
679 return ret;
680}
681
[3914]682int roar_sync         (struct roar_connection * con) {
683 // wait for any non-client reqs
684 return roar_wait_msg(con, 0x0000, 0x8000);
685}
686
687int roar_wait_msg     (struct roar_connection * con, int16_t seq, int16_t seqmask) {
[5148]688 roar_err_set(ROAR_ERROR_NOSYS);
[3914]689 return -1;
690}
[3913]691
[3836]692int roar_noop         (struct roar_connection * con) {
693 struct roar_message mes;
694
695 if ( con == NULL ) {
[5148]696  roar_err_set(ROAR_ERROR_FAULT);
[3836]697  return -1;
698 }
699
700 memset(&mes, 0, sizeof(mes));
701
702 mes.cmd = ROAR_CMD_NOOP;
[5144]703 mes.stream = -1;
[3836]704
[5146]705 return roar_req3(con, &mes, NULL);
[3836]706}
707
[5114]708int roar_identify   (struct roar_connection * con, const char * name) {
[0]709 struct roar_message mes;
[5132]710 uint32_t pid;
[0]711 int max_len;
712
[4873]713 roar_err_set(ROAR_ERROR_UNKNOWN);
[807]714
[0]715 ROAR_DBG("roar_identify(*): try to identify myself...");
716
[3875]717 memset(&mes, 0, sizeof(mes));
718
[0]719 mes.cmd    = ROAR_CMD_IDENTIFY;
[5144]720 mes.stream = -1;
721 mes.pos    =  0;
[0]722
723 ROAR_DBG("roar_identify(*): name=%p", name);
724
725 if ( name == NULL )
726  name = "libroar client";
727
728 ROAR_DBG("roar_identify(*): name=%p", name);
729
[5114]730 max_len = roar_mm_strlen(name);
[0]731 ROAR_DBG("roar_identify(*): strlen(name) = %i", max_len);
732
733 if ( max_len > (LIBROAR_BUFFER_MSGDATA - 5) )
734  max_len = LIBROAR_BUFFER_MSGDATA - 5;
735
736 mes.datalen = 5 + max_len;
737 mes.data[0] = 1;
738
739 pid = getpid();
[5132]740 mes.data[1] = (pid & 0xFF000000UL) >> 24;
741 mes.data[2] = (pid & 0x00FF0000UL) >> 16;
742 mes.data[3] = (pid & 0x0000FF00UL) >>  8;
743 mes.data[4] = (pid & 0x000000FFUL) >>  0;
744 ROAR_DBG("roar_identify(*): pid = %i", (int)pid);
[0]745
746 strncpy(mes.data+5, name, max_len);
747
[5146]748 return roar_req3(con, &mes, NULL);
[0]749}
750
751//ll
Note: See TracBrowser for help on using the repository browser.