source: roaraudio/libroar/roardl.c @ 5381:430b1d26e12d

Last change on this file since 5381:430b1d26e12d was 5381:430b1d26e12d, checked in by phi, 10 years ago

updated copyright years

File size: 15.7 KB
Line 
1//roardl.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010-2012
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#if defined(ROAR_HAVE_LIBDL) && !defined(RTLD_NEXT)
39#define RTLD_NEXT ((void *) -1L)
40#endif
41
42struct roar_dl_lhandle {
43 size_t refc; // currently unused.
44 int flags;
45 char * libname; // only used for ROAR_DL_FLAG_STATIC.
46 struct roar_dl_librarypara * para;
47 struct roar_dl_libraryinst * lib;
48 struct {
49  struct roar_error_state error_state;
50  void *  global_data;
51  void *  global_data_state;
52  struct roar_notify_core * notifycore;
53 } context;
54#if defined(ROAR_HAVE_LIBDL)
55 void * handle;
56#endif
57};
58
59
60struct roar_dl_librarypara * roar_dl_para_new(const char * args, void * binargv,
61                                              const char * appname, const char * abiversion) {
62 struct roar_dl_librarypara * ret = roar_mm_malloc(sizeof(struct roar_dl_librarypara));
63 ssize_t argc;
64 int err;
65
66 if ( ret == NULL )
67  return NULL;
68
69 memset(ret, 0, sizeof(struct roar_dl_librarypara));
70
71 ret->version    = ROAR_DL_LIBPARA_VERSION;
72 ret->len        = sizeof(struct roar_dl_librarypara);
73 ret->refc       = 1;
74 ret->argc       = 0;
75 ret->argv       = NULL;
76 ret->args_store = NULL;
77 ret->binargv    = binargv;
78 ret->appname    = appname;
79 ret->abiversion = abiversion;
80
81 if ( args != NULL ) {
82  ret->args_store = roar_mm_strdup(args);
83  if ( ret->args_store == NULL ) {
84   err = roar_error;
85   roar_mm_free(ret);
86   roar_error = err;
87   return NULL;
88  }
89
90  argc = roar_keyval_split(&(ret->argv), ret->args_store, NULL, NULL, 0);
91  if ( argc == -1 ) {
92   err = roar_error;
93   roar_mm_free(ret->args_store);
94   roar_mm_free(ret);
95   roar_error = err;
96   return NULL;
97  }
98
99  ret->argc = argc;
100 }
101
102 return ret;
103}
104
105int roar_dl_para_ref                    (struct roar_dl_librarypara * para) {
106 if ( para == NULL ) {
107  roar_err_set(ROAR_ERROR_FAULT);
108  return -1;
109 }
110
111 para->refc++;
112
113 return 0;
114}
115
116int roar_dl_para_unref                  (struct roar_dl_librarypara * para) {
117 if ( para == NULL ) {
118  roar_err_set(ROAR_ERROR_FAULT);
119  return -1;
120 }
121
122 para->refc--;
123
124 if ( para->refc )
125  return 0;
126
127 if ( para->notifycore != NULL )
128  roar_notify_core_unref(para->notifycore);
129
130 if ( para->args_store != NULL ) {
131  roar_mm_free(para->args_store);
132  roar_mm_free(para->argv);
133 }
134
135 roar_mm_free(para);
136
137 return 0;
138}
139int roar_dl_para_check_version          (struct roar_dl_librarypara * para,
140                                         const char * appname, const char * abiversion) {
141 if ( para == NULL ) {
142  roar_err_set(ROAR_ERROR_FAULT);
143  return -1;
144 }
145
146 // check if both appnames are NULL or non-NULL.
147 if ( (para->appname == NULL && appname != NULL) || (para->appname != NULL && appname == NULL) ) {
148  roar_err_set(ROAR_ERROR_BADHOST);
149  return -1;
150 }
151
152 // check if the appname matches if given.
153 if ( para->appname != NULL && !!strcmp(para->appname, appname) ) {
154  roar_err_set(ROAR_ERROR_BADHOST);
155  return -1;
156 }
157
158 // check if both ABI versions are NULL or non-NULL.
159 if ( (para->abiversion == NULL && abiversion != NULL) || (para->abiversion != NULL && abiversion == NULL) ) {
160  roar_err_set(ROAR_ERROR_BADVERSION);
161  return -1;
162 }
163
164 // check if the ABI versions matches if given.
165 if ( para->abiversion != NULL && !!strcmp(para->abiversion, abiversion) ) {
166  roar_err_set(ROAR_ERROR_BADVERSION);
167  return -1;
168 }
169
170 return 0;
171}
172
173
174#if defined(ROAR_HAVE_LIBDL)
175static void * _roardl2ldl (struct roar_dl_lhandle * lhandle) {
176 ROAR_DBG("_roardl2ldl(lhandle=%p) = ?", lhandle);
177
178 if ( lhandle == ROAR_DL_HANDLE_DEFAULT ) {
179  ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_DEFAULT);
180  return RTLD_DEFAULT;
181 }
182
183 if ( lhandle == ROAR_DL_HANDLE_NEXT ) {
184  ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)RTLD_NEXT);
185  return RTLD_NEXT;
186 }
187
188 ROAR_DBG("_roardl2ldl(lhandle=%p) = %p", lhandle, (void*)(lhandle->handle));
189 return lhandle->handle;
190}
191#endif
192
193struct roar_dl_lhandle * roar_dl_open(const char * filename, int flags,
194                                      int ra_init, struct roar_dl_librarypara * para) {
195 struct roar_dl_lhandle * ret = NULL;
196#if defined(ROAR_HAVE_LIBDL)
197#ifdef RTLD_DEEPBIND
198 int libdl_flags = RTLD_DEEPBIND;
199#else
200 int libdl_flags = 0;
201#endif
202#endif
203 int err;
204
205 if ( flags == ROAR_DL_FLAG_DEFAULTS )
206  flags = ROAR_DL_FLAG_NONE;
207
208#if defined(ROAR_HAVE_LIBDL)
209 if ( flags & ROAR_DL_FLAG_LAZY ) {
210  libdl_flags |= RTLD_LAZY;
211 } else {
212  libdl_flags |= RTLD_NOW;
213 }
214#endif
215
216 if ( (ret = roar_mm_malloc(sizeof(struct roar_dl_lhandle))) == NULL )
217  return NULL;
218
219 memset(ret, 0, sizeof(struct roar_dl_lhandle));
220
221 roar_err_initstore(&(ret->context.error_state));
222
223 ret->flags = flags;
224 ret->refc  = 1;
225
226 if ( flags & ROAR_DL_FLAG_STATIC ) {
227  if ( filename == NULL ) {
228   ret->libname = NULL;
229  } else {
230   ret->libname = roar_mm_strdup(filename);
231  }
232 } else {
233#if defined(ROAR_HAVE_LIBDL)
234  ret->handle = dlopen(filename, libdl_flags);
235
236  if ( ret->handle == NULL ) {
237   ROAR_DBG("roar_dl_open(filename='%s', flags=%i, ra_init=%i, para=%p): Can not load library: %s", filename, flags, ra_init, para, roar_dl_errstr(ret));
238   roar_mm_free(ret);
239   return NULL;
240  }
241#else
242  roar_mm_free(ret);
243  roar_err_set(ROAR_ERROR_NOSYS);
244  return NULL;
245#endif
246 }
247
248 ret->para = para;
249
250 if ( ra_init ) {
251  if ( roar_dl_ra_init(ret, NULL, para) == -1 ) {
252   err = roar_error;
253   ROAR_WARN("roar_dl_open(filename='%s', flags=%i, ra_init=%i, para=%p): Can not init RA lib: %s", filename, flags, ra_init, para, roar_error2str(err));
254#if defined(ROAR_HAVE_LIBDL)
255   if ( ret->handle != NULL )
256    dlclose(ret->handle);
257#endif
258   roar_mm_free(ret);
259   roar_error = err;
260   return NULL;
261  }
262 }
263
264 if ( para != NULL )
265  roar_dl_para_ref(para);
266
267 return ret;
268}
269
270int                      roar_dl_ref    (struct roar_dl_lhandle * lhandle) {
271 if ( (void*)lhandle < (void*)128 ) {
272  roar_err_set(ROAR_ERROR_BADFH);
273  return -1;
274 }
275
276 lhandle->refc++;
277
278 return 0;
279}
280
281int                      roar_dl_unref  (struct roar_dl_lhandle * lhandle) {
282 int ret = -1;
283
284 if ( (void*)lhandle < (void*)128 ) {
285  roar_err_set(ROAR_ERROR_BADFH);
286  return -1;
287 }
288
289 lhandle->refc++;
290
291 if ( lhandle->refc )
292  return 0;
293
294 if ( lhandle->lib != NULL && lhandle->lib->unload != NULL ) {
295  roar_dl_context_restore(lhandle);
296  lhandle->lib->unload(lhandle->para, lhandle->lib);
297  roar_dl_context_store(lhandle);
298 }
299
300#if defined(ROAR_HAVE_LIBDL)
301 if ( lhandle->handle == NULL ) {
302  ret = 0;
303 } else {
304  ret = dlclose(_roardl2ldl(lhandle));
305 }
306#else
307 ret = -1;
308#endif
309
310 if ( lhandle->context.global_data != NULL )
311  roar_mm_free(lhandle->context.global_data);
312
313 if ( lhandle->para != NULL )
314  roar_dl_para_unref(lhandle->para);
315
316 if ( lhandle->libname != NULL )
317  roar_mm_free(lhandle->libname);
318
319 roar_mm_free(lhandle);
320
321 return ret;
322}
323
324void                   * roar_dl_getsym(struct roar_dl_lhandle * lhandle, const char * sym, int type) {
325#if defined(ROAR_HAVE_LIBDL)
326 void * ret = dlsym(_roardl2ldl(lhandle), sym);
327
328 (void)type;
329
330 ROAR_DBG("roar_dl_getsym(lhandle=%p, sym='%s', type=%i): errno=%s, dlerror()='%s'", lhandle, sym, type, ret, strerror(errno), dlerror());
331 ROAR_DBG("roar_dl_getsym(lhandle=%p, sym='%s', type=%i) = %p", lhandle, sym, type, ret);
332
333 return ret;
334#else
335 ROAR_DBG("roar_dl_getsym(lhandle=%p, sym='%s', type=%i) = NULL // errno=NOSYS", lhandle, sym, type, ret);
336 roar_err_set(ROAR_ERROR_NOSYS);
337 return NULL;
338#endif
339}
340
341int                      roar_dl_ra_init(struct roar_dl_lhandle * lhandle,
342                                         const char * prefix,
343                                         struct roar_dl_librarypara * para) {
344#define _SUFFIX "_roaraudio_library_init"
345 char name[80] = _SUFFIX;
346 struct roar_dl_libraryinst * (*func)(struct roar_dl_librarypara * para);
347 struct roar_dl_libraryinst * lib;
348 struct roar_dl_lhandle     * getsymhandle = lhandle;
349 void * global_data_state = NULL;
350 int i;
351
352 if ( (void*)lhandle < (void*)128 ) {
353  if ( prefix == NULL )
354   return -1;
355 } else {
356  if ( prefix == NULL )
357   prefix = lhandle->libname;
358
359  if ( para == NULL )
360   para = lhandle->para;
361
362  if ( lhandle->flags & ROAR_DL_FLAG_STATIC )
363   getsymhandle = ROAR_DL_HANDLE_DEFAULT;
364 }
365
366
367 if ( prefix != NULL ) {
368  roar_mm_strscpy(name, "_");
369  roar_mm_strscat(name, prefix);
370  roar_mm_strscat(name, _SUFFIX);
371 }
372
373 ROAR_DBG("roar_dl_ra_init(lhandle=%p, prefix='%s'): name='%s'", lhandle, prefix, name);
374
375 if ( (func = roar_dl_getsym(getsymhandle, name, -1)) == NULL ) {
376  ROAR_DBG("roar_dl_ra_init(lhandle=%p, prefix='%s') = -1", lhandle, prefix);
377  return -1;
378 }
379
380 ROAR_DBG("roar_dl_ra_init(lhandle=%p, prefix='%s'): func=%p", lhandle, prefix, func);
381
382 lib = func(para);
383
384 if ( lib == NULL )
385  return -1;
386
387 if ( lib->version != ROAR_DL_LIBINST_VERSION )
388  return -1;
389
390 if ( sizeof(struct roar_dl_libraryinst) > lib->len )
391  return -1;
392
393 if ( lib->host_appname != NULL || lib->host_abiversion != NULL ) {
394  // check for correct host.
395  if ( para == NULL ) {
396   roar_err_set(ROAR_ERROR_INVAL);
397   return -1;
398  }
399  if ( roar_dl_para_check_version(para, lib->host_appname, lib->host_abiversion) == -1 )
400   return -1;
401 }
402
403 if ( (lib->libdep == NULL && lib->libdep_len) || (lib->libdep != NULL && !lib->libdep_len) ) {
404  roar_err_set(ROAR_ERROR_BADLIB);
405  return -1;
406 }
407
408 if ( lib->libdep != NULL && lib->libdep_len ) {
409  // dynamic loader infos are currently not supported.
410  roar_err_set(ROAR_ERROR_NOTSUP);
411  return -1;
412 }
413
414 if ( !((void*)lhandle < (void*)128) ) {
415  lhandle->lib = lib;
416
417  if ( lib->global_data_len ) {
418   lhandle->context.global_data = roar_mm_malloc(lib->global_data_len);
419   if ( lhandle->context.global_data == NULL )
420    return -1;
421
422   if ( lib->global_data_init == NULL ) {
423    memset(lhandle->context.global_data, 0, lib->global_data_len);
424   } else {
425    memcpy(lhandle->context.global_data, lib->global_data_init, lib->global_data_len);
426   }
427  }
428 }
429
430 if ( lib->global_data_pointer != NULL ) {
431  global_data_state = *(lib->global_data_pointer);
432  if ( (void*)lhandle < (void*)128 ) {
433   *(lib->global_data_pointer) = lib->global_data_init;
434  } else {
435   *(lib->global_data_pointer) = lhandle->context.global_data;
436  }
437 }
438
439 for (i = 0; i < ROAR_DL_FN_MAX; i++) {
440  if ( lib->func[i] != NULL )
441   lib->func[i](para, lib);
442 }
443
444 if ( lib->global_data_pointer != NULL ) {
445  if ( !((void*)lhandle < (void*)128) ) {
446   *(lib->global_data_pointer) = global_data_state;
447  }
448 }
449
450 return 0;
451}
452
453const char * roar_dl_errstr(struct roar_dl_lhandle * lhandle) {
454#if defined(ROAR_HAVE_LIBDL)
455 (void)lhandle;
456 return dlerror();
457#else
458 return NULL;
459#endif
460}
461
462struct roar_dl_librarypara       * roar_dl_getpara(struct roar_dl_lhandle * lhandle) {
463 if ( (void*)lhandle < (void*)128 ) {
464  roar_err_set(ROAR_ERROR_NOTSUP);
465  return NULL;
466 }
467
468 if ( lhandle->para == NULL ) {
469  roar_err_set(ROAR_ERROR_NOENT);
470  return NULL;
471 }
472
473 if ( roar_dl_para_ref(lhandle->para) == -1 )
474  return NULL;
475
476 return lhandle->para;
477}
478
479const struct roar_dl_libraryname * roar_dl_getlibname(struct roar_dl_lhandle * lhandle) {
480 if ( (void*)lhandle < (void*)128 ) {
481  roar_err_set(ROAR_ERROR_NOTSUP);
482  return NULL;
483 }
484
485 if ( lhandle->lib == NULL ) {
486  roar_err_set(ROAR_ERROR_BADLIB);
487  return NULL;
488 }
489
490 if ( lhandle->lib->libname == NULL ) {
491  roar_err_set(ROAR_ERROR_NOENT);
492  return NULL;
493 }
494
495 if ( lhandle->lib->libname->version != ROAR_DL_LIBNAME_VERSION ) {
496  roar_err_set(ROAR_ERROR_BADVERSION);
497  return NULL;
498 }
499
500 if ( lhandle->lib->libname->len != sizeof(struct roar_dl_libraryname) ) {
501  roar_err_set(ROAR_ERROR_HOLE);
502  return NULL;
503 }
504
505 return lhandle->lib->libname;
506}
507
508int                      roar_dl_context_restore(struct roar_dl_lhandle * lhandle) {
509 struct roar_error_state error_state;
510
511 ROAR_DBG("roar_dl_context_restore(lhandle=%p) = ?", lhandle);
512
513 if ( (void*)lhandle < (void*)128 ) {
514  ROAR_DBG("roar_dl_context_restore(lhandle=%p) = -1 // errno=NOTSUP", lhandle);
515  roar_err_set(ROAR_ERROR_NOTSUP);
516  return -1;
517 }
518
519 roar_err_store(&error_state);
520 roar_err_restore(&(lhandle->context.error_state));
521 lhandle->context.error_state = error_state;
522
523 if ( lhandle->lib->global_data_pointer != NULL ) {
524  ROAR_DBG("roar_dl_context_restore(lhandle=%p): gptr(%p): %p -> %p", lhandle,
525           lhandle->lib->global_data_pointer, *(lhandle->lib->global_data_pointer), lhandle->context.global_data);
526  lhandle->context.global_data_state = *(lhandle->lib->global_data_pointer);
527  *(lhandle->lib->global_data_pointer) = lhandle->context.global_data;
528 }
529
530 if ( lhandle->para->notifycore != NULL )
531  lhandle->context.notifycore = roar_notify_core_swap_global(lhandle->para->notifycore);
532
533 ROAR_DBG("roar_dl_context_restore(lhandle=%p) = 0", lhandle);
534 return 0;
535}
536
537int                      roar_dl_context_store(struct roar_dl_lhandle * lhandle) {
538 struct roar_error_state error_state;
539
540 ROAR_DBG("roar_dl_context_store(lhandle=%p) = ?", lhandle);
541
542 if ( (void*)lhandle < (void*)128 ) {
543  ROAR_DBG("roar_dl_context_store(lhandle=%p) = -1 // errno=NOTSUP", lhandle);
544  roar_err_set(ROAR_ERROR_NOTSUP);
545  return -1;
546 }
547
548 if ( lhandle->para->notifycore != NULL ) {
549  roar_notify_core_unref(roar_notify_core_swap_global(lhandle->context.notifycore));
550  roar_notify_core_unref(lhandle->context.notifycore);
551  lhandle->context.notifycore = NULL;
552 }
553
554 if ( lhandle->lib->global_data_pointer != NULL ) {
555  ROAR_DBG("roar_dl_context_store(lhandle=%p): gptr(%p): %p -> %p", lhandle,
556           lhandle->lib->global_data_pointer, *(lhandle->lib->global_data_pointer), lhandle->context.global_data_state);
557  *(lhandle->lib->global_data_pointer) = lhandle->context.global_data_state;
558 }
559
560 roar_err_store(&error_state);
561 roar_err_restore(&(lhandle->context.error_state));
562 lhandle->context.error_state = error_state;
563
564 ROAR_DBG("roar_dl_context_store(lhandle=%p) = 0", lhandle);
565 return 0;
566}
567
568int                      roar_dl_appsched_trigger(struct roar_dl_lhandle * lhandle, enum roar_dl_appsched_trigger trigger) {
569 int (*func)  (struct roar_dl_librarypara * para) = NULL;
570 int ret;
571
572 if ( (void*)lhandle < (void*)128 ) {
573  roar_err_set(ROAR_ERROR_NOTSUP);
574  return -1;
575 }
576
577 if ( lhandle->lib->appsched == NULL ) {
578  roar_err_set(ROAR_ERROR_NOENT);
579  return -1;
580 }
581
582 switch (trigger) {
583#define _trig(lname,uname) \
584  case ROAR_DL_APPSCHED_ ## uname :             \
585    func = lhandle->lib->appsched->lname;       \
586   break;
587  _trig(init, INIT);
588  _trig(free, FREE);
589  _trig(update, UPDATE);
590  _trig(tick, TICK);
591  _trig(wait, WAIT);
592// use ifndef here so warnings of unhandled enum values will be shown in DEBUG mode.
593#ifndef DEBUG
594  default:
595    roar_err_set(ROAR_ERROR_BADRQC);
596    return -1;
597   break;
598#endif
599 }
600
601 if ( func == NULL ) {
602  roar_err_set(ROAR_ERROR_NOENT);
603  return -1;
604 }
605
606 roar_dl_context_restore(lhandle);
607 ret = func(lhandle->para);
608 roar_dl_context_store(lhandle);
609 return ret;
610}
611
612//ll
Note: See TracBrowser for help on using the repository browser.