jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1099 Commits
8 Branches
255MB
Tree: 95e797f457
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '95e797f457'
${ noResults }
jack2/common/JackDriverLoader.cpp

732 lines
22KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2001-2005 Paul Davis

  3. Copyright (C) 2004-2008 Grame

  4. 

  5. This program is free software; you can redistribute it and/or modify

  6. it under the terms of the GNU General Public License as published by

  7. the Free Software Foundation; either version 2 of the License, or

  8. (at your option) any later version.

  9. 

  10. This program is distributed in the hope that it will be useful,

  11. but WITHOUT ANY WARRANTY; without even the implied warranty of

  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13. GNU General Public License for more details.

  14. 

  15. You should have received a copy of the GNU General Public License

  16. along with this program; if not, write to the Free Software

  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #if defined(HAVE_CONFIG_H)

  22. #include "config.h"

  23. #endif

  24. 

  25. #ifdef WIN32

  26. #pragma warning (disable : 4786)

  27. #endif

  28. 

  29. #ifndef WIN32

  30. #ifndef ADDON_DIR

  31. #include "config.h"

  32. #endif

  33. #endif

  34. 

  35. #include "JackDriverLoader.h"

  36. #include "JackConstants.h"

  37. #include "JackError.h"

  38. #include <getopt.h>

  39. #include <stdio.h>

  40. 

  41. #ifndef WIN32

  42. #include <dirent.h>

  43. #endif

  44. 

  45. #include <errno.h>

  46. 

  47. jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver_t * driver);

  48. 

  49. static void

  50. jack_print_driver_options (jack_driver_desc_t * desc, FILE *file)

  51. {

  52.     unsigned long i;

  53.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  54. 

  55.     for (i = 0; i < desc->nparams; i++) {

  56.         switch (desc->params[i].type) {

  57.             case JackDriverParamInt:

  58.                 sprintf (arg_default, "%" "i", desc->params[i].value.i);

  59.                 break;

  60.             case JackDriverParamUInt:

  61.                 sprintf (arg_default, "%" "u", desc->params[i].value.ui);

  62.                 break;

  63.             case JackDriverParamChar:

  64.                 sprintf (arg_default, "%c", desc->params[i].value.c);

  65.                 break;

  66.             case JackDriverParamString:

  67.                 if (desc->params[i].value.str && strcmp (desc->params[i].value.str, "") != 0)

  68.                     sprintf (arg_default, "%s", desc->params[i].value.str);

  69.                 else

  70.                     sprintf (arg_default, "none");

  71.                 break;

  72.             case JackDriverParamBool:

  73.                 sprintf (arg_default, "%s", desc->params[i].value.i ? "true" : "false");

  74.                 break;

  75.         }

  76. 

  77.         fprintf (file, "\t-%c, --%s \t%s (default: %s)\n",

  78.                  desc->params[i].character,

  79.                  desc->params[i].name,

  80.                  desc->params[i].short_desc,

  81.                  arg_default);

  82.     }

  83. }

  84. 

  85. static void

  86. jack_print_driver_param_usage (jack_driver_desc_t * desc, unsigned long param, FILE *file)

  87. {

  88.     fprintf (file, "Usage information for the '%s' parameter for driver '%s':\n",

  89.              desc->params[param].name, desc->name);

  90.     fprintf (file, "%s\n", desc->params[param].long_desc);

  91. }

  92. 

  93. int

  94. jack_parse_driver_params (jack_driver_desc_t * desc, int argc, char* argv[], JSList ** param_ptr)

  95. {

  96.     struct option * long_options;

  97.     char * options, * options_ptr;

  98.     unsigned long i;

  99.     int opt;

  100.     unsigned int param_index;

  101.     JSList * params = NULL;

  102.     jack_driver_param_t * driver_param;

  103. 

  104.     if (argc <= 1) {

  105.         *param_ptr = NULL;

  106.         return 0;

  107.     }

  108. 

  109.     /* check for help */

  110.     if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {

  111.         if (argc > 2) {

  112.             for (i = 0; i < desc->nparams; i++) {

  113.                 if (strcmp (desc->params[i].name, argv[2]) == 0) {

  114.                     jack_print_driver_param_usage (desc, i, stdout);

  115.                     return 1;

  116.                 }

  117.             }

  118. 

  119.             fprintf (stderr, "jackd: unknown option '%s' "

  120.                      "for driver '%s'\n", argv[2],

  121.                      desc->name);

  122.         }

  123. 

  124.         printf ("Parameters for driver '%s' (all parameters are optional):\n", desc->name);

  125.         jack_print_driver_options (desc, stdout);

  126.         return 1;

  127.     }

  128. 

  129.     /* set up the stuff for getopt */

  130.     options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));

  131.     long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));

  132. 

  133.     options_ptr = options;

  134.     for (i = 0; i < desc->nparams; i++) {

  135.         sprintf (options_ptr, "%c::", desc->params[i].character);

  136.         options_ptr += 3;

  137.         long_options[i].name = desc->params[i].name;

  138.         long_options[i].flag = NULL;

  139.         long_options[i].val = desc->params[i].character;

  140.         long_options[i].has_arg = optional_argument;

  141.     }

  142. 

  143.     /* create the params */

  144.     optind = 0;

  145.     opterr = 0;

  146.     while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {

  147. 

  148.         if (opt == ':' || opt == '?') {

  149.             if (opt == ':') {

  150.                 fprintf (stderr, "Missing option to argument '%c'\n", optopt);

  151.             } else {

  152.                 fprintf (stderr, "Unknownage with option '%c'\n", optopt);

  153.             }

  154. 

  155.             fprintf (stderr, "Options for driver '%s':\n", desc->name);

  156.             jack_print_driver_options (desc, stderr);

  157.             exit (1);

  158.         }

  159. 

  160.         for (param_index = 0; param_index < desc->nparams; param_index++) {

  161.             if (opt == desc->params[param_index].character) {

  162.                 break;

  163.             }

  164.         }

  165. 

  166.         driver_param = (jack_driver_param_t*)calloc (1, sizeof (jack_driver_param_t));

  167.         driver_param->character = desc->params[param_index].character;

  168. 

  169.         if (!optarg && optind < argc &&

  170.                 strlen(argv[optind]) &&

  171.                 argv[optind][0] != '-') {

  172.             optarg = argv[optind];

  173.         }

  174. 

  175.         if (optarg) {

  176.             switch (desc->params[param_index].type) {

  177.                 case JackDriverParamInt:

  178.                     driver_param->value.i = atoi (optarg);

  179.                     break;

  180.                 case JackDriverParamUInt:

  181.                     driver_param->value.ui = strtoul (optarg, NULL, 10);

  182.                     break;

  183.                 case JackDriverParamChar:

  184.                     driver_param->value.c = optarg[0];

  185.                     break;

  186.                 case JackDriverParamString:

  187.                     strncpy (driver_param->value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);

  188.                     break;

  189.                 case JackDriverParamBool:

  190. 

  191.                     /*

  192.                                 if (strcasecmp ("false", optarg) == 0 ||

  193.                                         strcasecmp ("off", optarg) == 0 ||

  194.                                         strcasecmp ("no", optarg) == 0 ||

  195.                                         strcasecmp ("0", optarg) == 0 ||

  196.                                         strcasecmp ("(null)", optarg) == 0 ) {

  197.                     */

  198.                     // steph

  199.                     if (strcmp ("false", optarg) == 0 ||

  200.                             strcmp ("off", optarg) == 0 ||

  201.                             strcmp ("no", optarg) == 0 ||

  202.                             strcmp ("0", optarg) == 0 ||

  203.                             strcmp ("(null)", optarg) == 0 ) {

  204.                         driver_param->value.i = false;

  205. 

  206.                     } else {

  207. 

  208.                         driver_param->value.i = true;

  209. 

  210.                     }

  211.                     break;

  212.             }

  213.         } else {

  214.             if (desc->params[param_index].type == JackDriverParamBool) {

  215.                 driver_param->value.i = true;

  216.             } else {

  217.                 driver_param->value = desc->params[param_index].value;

  218.             }

  219.         }

  220. 

  221.         params = jack_slist_append (params, driver_param);

  222.     }

  223. 

  224.     free (options);

  225.     free (long_options);

  226. 

  227.     if (param_ptr)

  228.         *param_ptr = params;

  229. 

  230.     return 0;

  231. }

  232. 

  233. EXPORT int

  234. jackctl_parse_driver_params (jackctl_driver *driver_ptr, int argc, char* argv[])

  235. {

  236.     struct option * long_options;

  237.     char * options, * options_ptr;

  238.     unsigned long i;

  239.     int opt;

  240.     JSList * node_ptr;

  241.     jackctl_parameter_t * param = NULL;

  242.     union jackctl_parameter_value value;

  243. 

  244.     if (argc <= 1)

  245.         return 0;

  246. 

  247.     const JSList * driver_params = jackctl_driver_get_parameters(driver_ptr);

  248.     if (driver_params == NULL)

  249.         return 1;

  250. 

  251.     jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);

  252. 

  253.     /* check for help */

  254.     if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {

  255.         if (argc > 2) {

  256.             for (i = 0; i < desc->nparams; i++) {

  257.                 if (strcmp (desc->params[i].name, argv[2]) == 0) {

  258.                     jack_print_driver_param_usage (desc, i, stdout);

  259.                     return 1;

  260.                 }

  261.             }

  262. 

  263.             fprintf (stderr, "jackd: unknown option '%s' "

  264.                      "for driver '%s'\n", argv[2],

  265.                      desc->name);

  266.         }

  267. 

  268.         printf ("Parameters for driver '%s' (all parameters are optional):\n", desc->name);

  269.         jack_print_driver_options (desc, stdout);

  270.         return 1;

  271.     }

  272. 

  273.    /* set up the stuff for getopt */

  274.     options = (char*)calloc (desc->nparams * 3 + 1, sizeof (char));

  275.     long_options = (option*)calloc (desc->nparams + 1, sizeof (struct option));

  276. 

  277.     options_ptr = options;

  278.     for (i = 0; i < desc->nparams; i++) {

  279.         sprintf (options_ptr, "%c::", desc->params[i].character);

  280.         options_ptr += 3;

  281.         long_options[i].name = desc->params[i].name;

  282.         long_options[i].flag = NULL;

  283.         long_options[i].val = desc->params[i].character;

  284.         long_options[i].has_arg = optional_argument;

  285.     }

  286. 

  287.     /* create the params */

  288.     optind = 0;

  289.     opterr = 0;

  290.     while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {

  291. 

  292.         if (opt == ':' || opt == '?') {

  293.             if (opt == ':') {

  294.                 fprintf (stderr, "Missing option to argument '%c'\n", optopt);

  295.             } else {

  296.                 fprintf (stderr, "Unknownage with option '%c'\n", optopt);

  297.             }

  298. 

  299.             fprintf (stderr, "Options for driver '%s':\n", desc->name);

  300.             jack_print_driver_options(desc, stderr);

  301.             return 1;

  302.         }

  303. 

  304.         node_ptr = (JSList *)driver_params;

  305.        	while (node_ptr) {

  306.             param = (jackctl_parameter_t*)node_ptr->data;

  307.             if (opt == jackctl_parameter_get_id(param)) {

  308.                 break;

  309.             }

  310.             node_ptr = node_ptr->next;

  311.         }

  312. 

  313.         if (!optarg && optind < argc &&

  314.             strlen(argv[optind]) &&

  315.             argv[optind][0] != '-') {

  316.             optarg = argv[optind];

  317.         }

  318. 

  319.         if (optarg) {

  320.             switch (jackctl_parameter_get_type(param)) {

  321.                 case JackDriverParamInt:

  322.                     value.i = atoi (optarg);

  323.                     jackctl_parameter_set_value(param, &value);

  324.                     break;

  325.                 case JackDriverParamUInt:

  326.                     value.ui = strtoul (optarg, NULL, 10);

  327.                     jackctl_parameter_set_value(param, &value);

  328.                     break;

  329.                 case JackDriverParamChar:

  330.                     value.c = optarg[0];

  331.                     jackctl_parameter_set_value(param, &value);

  332.                     break;

  333.                 case JackDriverParamString:

  334.                     strncpy (value.str, optarg, JACK_DRIVER_PARAM_STRING_MAX);

  335.                     jackctl_parameter_set_value(param, &value);

  336.                     break;

  337.                 case JackDriverParamBool:

  338.                     /*

  339.                      if (strcasecmp ("false", optarg) == 0 ||

  340.                          strcasecmp ("off", optarg) == 0 ||

  341.                          strcasecmp ("no", optarg) == 0 ||

  342.                          strcasecmp ("0", optarg) == 0 ||

  343.                          strcasecmp ("(null)", optarg) == 0 ) {

  344.                     */

  345.                     // steph

  346.                     if (strcmp ("false", optarg) == 0 ||

  347.                         strcmp ("off", optarg) == 0 ||

  348.                         strcmp ("no", optarg) == 0 ||

  349.                         strcmp ("0", optarg) == 0 ||

  350.                         strcmp ("(null)", optarg) == 0 ) {

  351.                         value.i = false;

  352.                     } else {

  353.                         value.i = true;

  354.                     }

  355.                     jackctl_parameter_set_value(param, &value);

  356.                     break;

  357.             }

  358.         } else {

  359.             if (jackctl_parameter_get_type(param) == JackParamBool) {

  360.                 value.i = true;

  361.             } else {

  362.                 value = jackctl_parameter_get_default_value(param);

  363.             }

  364.             jackctl_parameter_set_value(param, &value);

  365.         }

  366.     }

  367. 

  368.     free(options);

  369.     free(long_options);

  370.     return 0;

  371. }

  372. 

  373. int

  374. jack_parse_internal_client_params(jack_driver_desc_t* desc, int argc, char* argv[], JSList** param_ptr)

  375. {

  376.     char* options_list;

  377.     unsigned long i = 0;

  378.     unsigned int param = 0;

  379.     unsigned int param_id = 0;

  380.     JSList* params = NULL;

  381.     jack_driver_param_t* intclient_param;

  382. 

  383.     options_list = (char*) calloc ( desc->nparams + 1, sizeof ( char ) );

  384. 

  385.     for ( i = 0; i < desc->nparams; i++ )

  386.         sprintf ( ( options_list + i ), "%c", desc->params[i].character );

  387. 

  388.     for ( param = 0; param < argc; param++ )

  389.     {

  390.         if ( argv[param][0] == '-' )

  391.         {

  392.             //valid option

  393.             if ( strchr ( options_list, argv[param][1] ) != NULL )

  394.             {

  395.                 //associated parameter

  396.                 for ( param_id = 0; param_id < desc->nparams; param_id++ )

  397.                     if ( argv[param][1] == options_list[param_id] )

  398.                         break;

  399. 

  400.                 //allocate parameter

  401.                 intclient_param = (jack_driver_param_t*) calloc ( 1, sizeof ( jack_driver_param_t ) );

  402.                 intclient_param->character = desc->params[param_id].character;

  403. 

  404.                 switch ( desc->params[param_id].type )

  405.                 {

  406.                     case JackDriverParamInt:

  407.                         intclient_param->value.i = atoi ( argv[param + 1] );

  408.                         break;

  409.                     case JackDriverParamUInt:

  410.                         intclient_param->value.ui = strtoul ( argv[param + 1], NULL, 10 );

  411.                         break;

  412.                     case JackDriverParamChar:

  413.                         intclient_param->value.c = argv[param + 1][0];

  414.                         break;

  415.                     case JackDriverParamString:

  416.                         strncpy ( intclient_param->value.str, argv[param + 1], JACK_DRIVER_PARAM_STRING_MAX );

  417.                         break;

  418.                     case JackDriverParamBool:

  419.                         if ( ( strcmp ( "false", argv[param + 1] ) == 0 ) ||

  420.                                 ( strcmp ( "off", argv[param + 1] ) == 0 ) || 

  421.                                 ( strcmp ( "no", argv[param + 1] ) == 0 ) || 

  422.                                 ( strcmp ( "0", argv[param + 1] ) == 0 ) || 

  423.                                 ( strcmp ( "(null)", argv[param + 1] ) == 0 ) )

  424.                             intclient_param->value.i = false;

  425.                         else

  426.                             intclient_param->value.i = true;

  427.                         break;

  428.                 }

  429.                 //add to the list

  430.                 params = jack_slist_append ( params, intclient_param );

  431.             }

  432.             //invalid option

  433.             else

  434.                 fprintf ( stderr, "Invalid option '%c'\n", argv[param][1] );

  435.         }

  436.     }

  437. 

  438.     free ( options_list );

  439. 

  440.     if ( param_ptr )

  441.         *param_ptr = params;

  442. 

  443.     return 0;

  444. }

  445. 

  446. jack_driver_desc_t *

  447. jack_find_driver_descriptor (JSList * drivers, const char * name)

  448. {

  449.     jack_driver_desc_t * desc = 0;

  450.     JSList * node;

  451. 

  452.     for (node = drivers; node; node = jack_slist_next (node)) {

  453.         desc = (jack_driver_desc_t *) node->data;

  454. 

  455.         if (strcmp (desc->name, name) != 0) {

  456.             desc = NULL;

  457.         } else {

  458.             break;

  459.         }

  460.     }

  461. 

  462.     return desc;

  463. }

  464. 

  465. jack_driver_desc_t *

  466. jack_drivers_get_descriptor (JSList * drivers, const char * sofile)

  467. {

  468.     jack_driver_desc_t * descriptor, * other_descriptor;

  469.     JackDriverDescFunction so_get_descriptor = NULL;

  470.     JSList * node;

  471.     void * dlhandle;

  472.     char * filename;

  473. #ifdef WIN32

  474.     int dlerr;

  475. #else

  476.     const char * dlerr;

  477. #endif

  478. 

  479.     int err;

  480.     const char* driver_dir;

  481. 

  482.     if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {

  483.         // for WIN32 ADDON_DIR is defined in JackConstants.h as relative path

  484.         // for posix systems, it is absolute path of default driver dir

  485. #ifdef WIN32

  486.         char temp_driver_dir1[512];

  487.         char temp_driver_dir2[512];

  488.         GetCurrentDirectory(512, temp_driver_dir1);

  489.         sprintf(temp_driver_dir2, "%s/%s", temp_driver_dir1, ADDON_DIR);

  490.         driver_dir = temp_driver_dir2;

  491. #else

  492.         driver_dir = ADDON_DIR;

  493. #endif

  494.     }

  495. 

  496.     filename = (char *)malloc(strlen (driver_dir) + 1 + strlen(sofile) + 1);

  497.     sprintf (filename, "%s/%s", driver_dir, sofile);

  498. 

  499.     if ((dlhandle = LoadDriverModule(filename)) == NULL) {

  500. #ifdef WIN32

  501.         jack_error ("could not open driver .dll '%s': %ld\n", filename, GetLastError());

  502. #else

  503.         jack_error ("could not open driver .so '%s': %s\n", filename, dlerror());

  504. #endif

  505. 

  506.         free(filename);

  507.         return NULL;

  508.     }

  509. 

  510.     so_get_descriptor = (JackDriverDescFunction)

  511.                         GetProc(dlhandle, "driver_get_descriptor");

  512. 

  513. #ifdef WIN32

  514.     if ((so_get_descriptor == NULL) && (dlerr = GetLastError()) != 0) {

  515.         jack_log("Jack::jack_drivers_get_descriptor : dll is not a driver, error ld", dlerr);

  516. #else

  517.     if ((so_get_descriptor == NULL) && (dlerr = dlerror ()) != NULL) {

  518.         jack_error("%s", dlerr);

  519. #endif

  520. 

  521.         UnloadDriverModule(dlhandle);

  522.         free(filename);

  523.         return NULL;

  524.     }

  525. 

  526.     if ((descriptor = so_get_descriptor ()) == NULL) {

  527.         jack_error("driver from '%s' returned NULL descriptor\n", filename);

  528.         UnloadDriverModule(dlhandle);

  529.         free(filename);

  530.         return NULL;

  531.     }

  532. 

  533. #ifdef WIN32

  534.     if ((err = UnloadDriverModule(dlhandle)) == 0) {

  535.         jack_error ("error closing driver .so '%s': %ld\n", filename, GetLastError ());

  536.     }

  537. #else

  538.     if ((err = UnloadDriverModule(dlhandle)) != 0) {

  539.         jack_error ("error closing driver .so '%s': %s\n", filename, dlerror ());

  540.     }

  541. #endif

  542. 

  543.     /* check it doesn't exist already */

  544.     for (node = drivers; node; node = jack_slist_next (node)) {

  545.         other_descriptor = (jack_driver_desc_t *) node->data;

  546. 

  547.         if (strcmp(descriptor->name, other_descriptor->name) == 0) {

  548.             jack_error("the drivers in '%s' and '%s' both have the name '%s'; using the first\n",

  549.                        other_descriptor->file, filename, other_descriptor->name);

  550.             /* FIXME: delete the descriptor */

  551.             free(filename);

  552.             return NULL;

  553.         }

  554.     }

  555. 

  556.     strncpy(descriptor->file, filename, PATH_MAX);

  557.     free(filename);

  558.     return descriptor;

  559. }

  560. 

  561. #ifdef WIN32

  562. 

  563. JSList *

  564. jack_drivers_load (JSList * drivers) {

  565.     char * driver_dir;

  566.     char driver_dir_storage[512];

  567.     char dll_filename[512];

  568.     WIN32_FIND_DATA filedata;

  569.     HANDLE file;

  570.     const char * ptr = NULL;

  571.     JSList * driver_list = NULL;

  572.     jack_driver_desc_t * desc;

  573. 

  574.     if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {

  575.         // for WIN32 ADDON_DIR is defined in JackConstants.h as relative path

  576.         GetCurrentDirectory(512, driver_dir_storage);

  577.         strcat(driver_dir_storage, "/");

  578.         strcat(driver_dir_storage, ADDON_DIR);

  579.         driver_dir = driver_dir_storage;

  580.     }

  581. 

  582.     sprintf(dll_filename, "%s/*.dll", driver_dir);

  583. 

  584.     file = (HANDLE )FindFirstFile(dll_filename, &filedata);

  585. 

  586.     if (file == INVALID_HANDLE_VALUE) {

  587.         jack_error("error");

  588.         return NULL;

  589.     }

  590. 

  591.     do {

  592.         ptr = strrchr (filedata.cFileName, '.');

  593.         if (!ptr) {

  594.             continue;

  595.         }

  596.         ptr++;

  597.         if (strncmp ("dll", ptr, 3) != 0) {

  598.             continue;

  599.         }

  600. 

  601.         desc = jack_drivers_get_descriptor (drivers, filedata.cFileName);

  602.         if (desc) {

  603.             driver_list = jack_slist_append (driver_list, desc);

  604.         }

  605. 

  606.     } while (FindNextFile(file, &filedata));

  607. 

  608.     if (!driver_list) {

  609.         jack_error ("could not find any drivers in %s!\n", driver_dir);

  610.         return NULL;

  611.     }

  612. 

  613.     return driver_list;

  614. }

  615. 

  616. #else

  617. 

  618. JSList *

  619. jack_drivers_load (JSList * drivers) {

  620.     struct dirent * dir_entry;

  621.     DIR * dir_stream;

  622.     const char * ptr;

  623.     int err;

  624.     JSList * driver_list = NULL;

  625.     jack_driver_desc_t * desc;

  626. 

  627.     const char* driver_dir;

  628.     if ((driver_dir = getenv("JACK_DRIVER_DIR")) == 0) {

  629.         driver_dir = ADDON_DIR;

  630.     }

  631. 

  632.     /* search through the driver_dir and add get descriptors

  633.     from the .so files in it */

  634.     dir_stream = opendir (driver_dir);

  635.     if (!dir_stream) {

  636.         jack_error ("could not open driver directory %s: %s\n",

  637.                     driver_dir, strerror (errno));

  638.         return NULL;

  639.     }

  640. 

  641.     while ((dir_entry = readdir(dir_stream))) {

  642. 

  643.         /* check the filename is of the right format */

  644.         if (strncmp ("jack_", dir_entry->d_name, 5) != 0) {

  645.             continue;

  646.         }

  647. 

  648.         ptr = strrchr (dir_entry->d_name, '.');

  649.         if (!ptr) {

  650.             continue;

  651.         }

  652.         ptr++;

  653.         if (strncmp ("so", ptr, 2) != 0) {

  654.             continue;

  655.         }

  656. 

  657.         desc = jack_drivers_get_descriptor (drivers, dir_entry->d_name);

  658.         if (desc) {

  659.             driver_list = jack_slist_append (driver_list, desc);

  660.         }

  661.     }

  662. 

  663.     err = closedir (dir_stream);

  664.     if (err) {

  665.         jack_error ("error closing driver directory %s: %s\n",

  666.                     driver_dir, strerror (errno));

  667.     }

  668. 

  669.     if (!driver_list) {

  670.         jack_error ("could not find any drivers in %s!\n", driver_dir);

  671.         return NULL;

  672.     }

  673. 

  674.     return driver_list;

  675. }

  676. 

  677. #endif

  678. 

  679. jack_driver_info_t *

  680. jack_load_driver (jack_driver_desc_t * driver_desc) {

  681. #ifdef WIN32

  682.     int errstr;

  683. #else

  684.     const char * errstr;

  685. #endif

  686. 

  687.     jack_driver_info_t *info;

  688. 

  689.     info = (jack_driver_info_t *) calloc (1, sizeof (*info));

  690.     info->handle = LoadDriverModule (driver_desc->file);

  691. 

  692.     if (info->handle == NULL) {

  693. #ifdef WIN32

  694.         if ((errstr = GetLastError ()) != 0) {

  695.             jack_error ("can't load \"%s\": %ld", driver_desc->file,

  696.                         errstr);

  697. #else

  698.         if ((errstr = dlerror ()) != 0) {

  699.             jack_error ("can't load \"%s\": %s", driver_desc->file,

  700.                         errstr);

  701. #endif

  702. 

  703.         } else {

  704.             jack_error ("bizarre error loading driver shared "

  705.                         "object %s", driver_desc->file);

  706.         }

  707.         goto fail;

  708.     }

  709. 

  710.     info->initialize = (initialize)GetProc(info->handle, "driver_initialize");

  711. 

  712. #ifdef WIN32

  713.     if ((info->initialize == NULL) && (errstr = GetLastError ()) != 0) {

  714. #else

  715.     if ((info->initialize == NULL) && (errstr = dlerror ()) != 0) {

  716. #endif

  717.         jack_error ("no initialize function in shared object %s\n",

  718.                     driver_desc->file);

  719.         goto fail;

  720.     }

  721. 

  722.     return info;

  723. 

  724. fail:

  725.     if (info->handle) {

  726.         UnloadDriverModule(info->handle);

  727.     }

  728.     free (info);

  729.     return NULL;

  730. }