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.
1230 Commits
8 Branches
42MB
Tree: 1b10f1876f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b10f1876f'
${ noResults }
jack2/common/JackDriverLoader.cpp

836 lines
24KB
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. /*

  30. #ifndef WIN32

  31. #ifndef ADDON_DIR

  32. #include "config.h"

  33. #endif

  34. #endif

  35. */

  36. 

  37. #include "JackDriverLoader.h"

  38. #include "JackConstants.h"

  39. #include "JackError.h"

  40. #include <getopt.h>

  41. #include <stdio.h>

  42. 

  43. #ifndef WIN32

  44. #include <dirent.h>

  45. #endif

  46. 

  47. #include <errno.h>

  48. 

  49. jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver_t * driver);

  50. 

  51. static void

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

  53. {

  54.     unsigned long i;

  55.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  56. 

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

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

  59.             case JackDriverParamInt:

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

  61.                 break;

  62.             case JackDriverParamUInt:

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

  64.                 break;

  65.             case JackDriverParamChar:

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

  67.                 break;

  68.             case JackDriverParamString:

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

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

  71.                 else

  72.                     sprintf (arg_default, "none");

  73.                 break;

  74.             case JackDriverParamBool:

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

  76.                 break;

  77.         }

  78. 

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

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

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

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

  83.                  arg_default);

  84.     }

  85. }

  86. 

  87. static void

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

  89. {

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

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

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

  93. }

  94. 

  95. EXPORT void jack_free_driver_params(JSList * driver_params)

  96. {

  97.     JSList *node_ptr = driver_params;

  98.     JSList *next_node_ptr;

  99.     

  100.     while (node_ptr) {

  101.         next_node_ptr = node_ptr->next;

  102.         free(node_ptr->data);

  103.         free(node_ptr);

  104.         node_ptr = next_node_ptr;

  105.     }

  106. }

  107. 

  108. int

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

  110. {

  111.     struct option * long_options;

  112.     char * options, * options_ptr;

  113.     unsigned long i;

  114.     int opt;

  115.     unsigned int param_index;

  116.     JSList * params = NULL;

  117.     jack_driver_param_t * driver_param;

  118. 

  119.     if (argc <= 1) {

  120.         *param_ptr = NULL;

  121.         return 0;

  122.     }

  123. 

  124.     /* check for help */

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

  126.         if (argc > 2) {

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

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

  129.                     jack_print_driver_param_usage (desc, i, stdout);

  130.                     return 1;

  131.                 }

  132.             }

  133. 

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

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

  136.                      desc->name);

  137.         }

  138. 

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

  140.         jack_print_driver_options (desc, stdout);

  141.         return 1;

  142.     }

  143. 

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

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

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

  147. 

  148.     options_ptr = options;

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

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

  151.         options_ptr += 3;

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

  153.         long_options[i].flag = NULL;

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

  155.         long_options[i].has_arg = optional_argument;

  156.     }

  157. 

  158.     /* create the params */

  159.     optind = 0;

  160.     opterr = 0;

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

  162. 

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

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

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

  166.             } else {

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

  168.             }

  169. 

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

  171.             jack_print_driver_options (desc, stderr);

  172.             exit (1);

  173.         }

  174. 

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

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

  177.                 break;

  178.             }

  179.         }

  180. 

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

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

  183. 

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

  185.                 strlen(argv[optind]) &&

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

  187.             optarg = argv[optind];

  188.         }

  189. 

  190.         if (optarg) {

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

  192.                 case JackDriverParamInt:

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

  194.                     break;

  195.                 case JackDriverParamUInt:

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

  197.                     break;

  198.                 case JackDriverParamChar:

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

  200.                     break;

  201.                 case JackDriverParamString:

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

  203.                     break;

  204.                 case JackDriverParamBool:

  205. 

  206.                     /*

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

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

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

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

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

  212.                     */

  213.                     // steph

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

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

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

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

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

  219.                         driver_param->value.i = false;

  220. 

  221.                     } else {

  222. 

  223.                         driver_param->value.i = true;

  224. 

  225.                     }

  226.                     break;

  227.             }

  228.         } else {

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

  230.                 driver_param->value.i = true;

  231.             } else {

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

  233.             }

  234.         }

  235. 

  236.         params = jack_slist_append (params, driver_param);

  237.     }

  238. 

  239.     free (options);

  240.     free (long_options);

  241. 

  242.     if (param_ptr)

  243.         *param_ptr = params;

  244. 

  245.     return 0;

  246. }

  247. 

  248. EXPORT int

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

  250. {

  251.     struct option * long_options;

  252.     char * options, * options_ptr;

  253.     unsigned long i;

  254.     int opt;

  255.     JSList * node_ptr;

  256.     jackctl_parameter_t * param = NULL;

  257.     union jackctl_parameter_value value;

  258. 

  259.     if (argc <= 1)

  260.         return 0;

  261. 

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

  263.     if (driver_params == NULL)

  264.         return 1;

  265. 

  266.     jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);

  267. 

  268.     /* check for help */

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

  270.         if (argc > 2) {

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

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

  273.                     jack_print_driver_param_usage (desc, i, stdout);

  274.                     return 1;

  275.                 }

  276.             }

  277. 

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

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

  280.                      desc->name);

  281.         }

  282. 

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

  284.         jack_print_driver_options (desc, stdout);

  285.         return 1;

  286.     }

  287. 

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

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

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

  291. 

  292.     options_ptr = options;

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

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

  295.         options_ptr += 3;

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

  297.         long_options[i].flag = NULL;

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

  299.         long_options[i].has_arg = optional_argument;

  300.     }

  301. 

  302.     /* create the params */

  303.     optind = 0;

  304.     opterr = 0;

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

  306. 

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

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

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

  310.             } else {

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

  312.             }

  313. 

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

  315.             jack_print_driver_options(desc, stderr);

  316.             return 1;

  317.         }

  318. 

  319.         node_ptr = (JSList *)driver_params;

  320.        	while (node_ptr) {

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

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

  323.                 break;

  324.             }

  325.             node_ptr = node_ptr->next;

  326.         }

  327. 

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

  329.             strlen(argv[optind]) &&

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

  331.             optarg = argv[optind];

  332.         }

  333. 

  334.         if (optarg) {

  335.             switch (jackctl_parameter_get_type(param)) {

  336.                 case JackDriverParamInt:

  337.                     value.i = atoi (optarg);

  338.                     jackctl_parameter_set_value(param, &value);

  339.                     break;

  340.                 case JackDriverParamUInt:

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

  342.                     jackctl_parameter_set_value(param, &value);

  343.                     break;

  344.                 case JackDriverParamChar:

  345.                     value.c = optarg[0];

  346.                     jackctl_parameter_set_value(param, &value);

  347.                     break;

  348.                 case JackDriverParamString:

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

  350.                     jackctl_parameter_set_value(param, &value);

  351.                     break;

  352.                 case JackDriverParamBool:

  353.                     /*

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

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

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

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

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

  359.                     */

  360.                     // steph

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

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

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

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

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

  366.                         value.i = false;

  367.                     } else {

  368.                         value.i = true;

  369.                     }

  370.                     jackctl_parameter_set_value(param, &value);

  371.                     break;

  372.             }

  373.         } else {

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

  375.                 value.i = true;

  376.             } else {

  377.                 value = jackctl_parameter_get_default_value(param);

  378.             }

  379.             jackctl_parameter_set_value(param, &value);

  380.         }

  381.     }

  382. 

  383.     free(options);

  384.     free(long_options);

  385.     return 0;

  386. }

  387. 

  388. jack_driver_desc_t *

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

  390. {

  391.     jack_driver_desc_t * desc = 0;

  392.     JSList * node;

  393. 

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

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

  396. 

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

  398.             desc = NULL;

  399.         } else {

  400.             break;

  401.         }

  402.     }

  403. 

  404.     return desc;

  405. }

  406. 

  407. static jack_driver_desc_t *

  408. jack_get_descriptor (JSList * drivers, const char * sofile, const char * symbol)

  409. {

  410.     jack_driver_desc_t * descriptor, * other_descriptor;

  411.     JackDriverDescFunction so_get_descriptor = NULL;

  412.     JSList * node;

  413.     void * dlhandle;

  414.     char * filename;

  415. #ifdef WIN32

  416.     int dlerr;

  417. #else

  418.     const char * dlerr;

  419. #endif

  420. 

  421.     int err;

  422.     const char* driver_dir;

  423. 

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

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

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

  427. #ifdef WIN32

  428.         char temp_driver_dir1[512];

  429.         char temp_driver_dir2[512];

  430.         GetCurrentDirectory(512, temp_driver_dir1);

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

  432.         driver_dir = temp_driver_dir2;

  433. #else

  434.         driver_dir = ADDON_DIR;

  435. #endif

  436.     }

  437. 

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

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

  440. 

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

  442. #ifdef WIN32

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

  444. #else

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

  446. #endif

  447. 

  448.         free(filename);

  449.         return NULL;

  450.     }

  451. 

  452.     so_get_descriptor = (JackDriverDescFunction)

  453.                         GetProc(dlhandle, symbol);

  454. 

  455. #ifdef WIN32

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

  457.         jack_error("jack_get_descriptor err = %ld", dlerr);

  458. #else

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

  460.         jack_error("jack_get_descriptor err = %s", dlerr);

  461. #endif

  462. 

  463.         UnloadDriverModule(dlhandle);

  464.         free(filename);

  465.         return NULL;

  466.     }

  467. 

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

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

  470.         UnloadDriverModule(dlhandle);

  471.         free(filename);

  472.         return NULL;

  473.     }

  474. 

  475. #ifdef WIN32

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

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

  478.     }

  479. #else

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

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

  482.     }

  483. #endif

  484. 

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

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

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

  488. 

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

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

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

  492.             /* FIXME: delete the descriptor */

  493.             free(filename);

  494.             return NULL;

  495.         }

  496.     }

  497. 

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

  499.     free(filename);

  500.     return descriptor;

  501. }

  502. 

  503. static bool check_symbol(const char* sofile, const char* symbol)

  504. {   

  505.     void * dlhandle;

  506.     bool res = false;

  507.     const char* driver_dir;

  508. 

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

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

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

  512. #ifdef WIN32

  513.         char temp_driver_dir1[512];

  514.         char temp_driver_dir2[512];

  515.         GetCurrentDirectory(512, temp_driver_dir1);

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

  517.         driver_dir = temp_driver_dir2;

  518. #else

  519.         driver_dir = ADDON_DIR;

  520. #endif

  521.     }

  522.     

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

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

  525.     

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

  527. #ifdef WIN32

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

  529. #else

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

  531. #endif

  532.      } else {

  533.         res = (GetProc(dlhandle, symbol)) ? true : false;

  534.         UnloadDriverModule(dlhandle);

  535.     }

  536.     

  537.     free(filename);

  538.     return res;

  539. }

  540. 

  541. #ifdef WIN32

  542. 

  543. JSList *

  544. jack_drivers_load (JSList * drivers) {

  545.     char * driver_dir;

  546.     char driver_dir_storage[512];

  547.     char dll_filename[512];

  548.     WIN32_FIND_DATA filedata;

  549.     HANDLE file;

  550.     const char * ptr = NULL;

  551.     JSList * driver_list = NULL;

  552.     jack_driver_desc_t * desc;

  553. 

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

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

  556.         GetCurrentDirectory(512, driver_dir_storage);

  557.         strcat(driver_dir_storage, "/");

  558.         strcat(driver_dir_storage, ADDON_DIR);

  559.         driver_dir = driver_dir_storage;

  560.     }

  561. 

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

  563. 

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

  565. 

  566.     if (file == INVALID_HANDLE_VALUE) {

  567.         jack_error("error");

  568.         return NULL;

  569.     }

  570. 

  571.     do {

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

  573.         if (!ptr) {

  574.             continue;

  575.         }

  576.         ptr++;

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

  578.             continue;

  579.         }

  580. 

  581.         desc = jack_get_descriptor (drivers, filedata.cFileName, "driver_get_descriptor");

  582.         if (desc) {

  583.             driver_list = jack_slist_append (driver_list, desc);

  584.         }

  585. 

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

  587. 

  588.     if (!driver_list) {

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

  590.         return NULL;

  591.     }

  592. 

  593.     return driver_list;

  594. }

  595. 

  596. #else

  597. 

  598. JSList *

  599. jack_drivers_load (JSList * drivers) {

  600.     struct dirent * dir_entry;

  601.     DIR * dir_stream;

  602.     const char * ptr;

  603.     int err;

  604.     JSList * driver_list = NULL;

  605.     jack_driver_desc_t * desc;

  606. 

  607.     const char* driver_dir;

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

  609.         driver_dir = ADDON_DIR;

  610.     }

  611. 

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

  613.     from the .so files in it */

  614.     dir_stream = opendir (driver_dir);

  615.     if (!dir_stream) {

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

  617.                     driver_dir, strerror (errno));

  618.         return NULL;

  619.     }

  620. 

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

  622. 

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

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

  625.             continue;

  626.         }

  627. 

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

  629.         if (!ptr) {

  630.             continue;

  631.         }

  632.         ptr++;

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

  634.             continue;

  635.         }

  636. 

  637.         desc = jack_get_descriptor (drivers, dir_entry->d_name, "driver_get_descriptor");

  638.         if (desc) {

  639.             driver_list = jack_slist_append (driver_list, desc);

  640.         }

  641.     }

  642. 

  643.     err = closedir (dir_stream);

  644.     if (err) {

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

  646.                     driver_dir, strerror (errno));

  647.     }

  648. 

  649.     if (!driver_list) {

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

  651.         return NULL;

  652.     }

  653. 

  654.     return driver_list;

  655. }

  656. 

  657. #endif

  658. 

  659. #ifdef WIN32

  660. 

  661. JSList *

  662. jack_internals_load (JSList * internals) {

  663.     char * driver_dir;

  664.     char driver_dir_storage[512];

  665.     char dll_filename[512];

  666.     WIN32_FIND_DATA filedata;

  667.     HANDLE file;

  668.     const char * ptr = NULL;

  669.     JSList * driver_list = NULL;

  670.     jack_driver_desc_t * desc;

  671. 

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

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

  674.         GetCurrentDirectory(512, driver_dir_storage);

  675.         strcat(driver_dir_storage, "/");

  676.         strcat(driver_dir_storage, ADDON_DIR);

  677.         driver_dir = driver_dir_storage;

  678.     }

  679. 

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

  681. 

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

  683. 

  684.     if (file == INVALID_HANDLE_VALUE) {

  685.         jack_error("error");

  686.         return NULL;

  687.     }

  688. 

  689.     do {

  690.     

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

  692.         if (!ptr) {

  693.             continue;

  694.         }

  695.         ptr++;

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

  697.             continue;

  698.         }

  699.         

  700.         /* check if dll is an internal client */

  701.         if (!check_symbol(filedata.cFileName, "jack_internal_initialize")) {

  702.              continue;

  703.         }

  704.  

  705.         desc = jack_get_descriptor (internals, filedata.cFileName, "jack_get_descriptor");

  706.         if (desc) {

  707.             driver_list = jack_slist_append (driver_list, desc);

  708.         }

  709. 

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

  711. 

  712.     if (!driver_list) {

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

  714.         return NULL;

  715.     }

  716. 

  717.     return driver_list;

  718. }

  719. 

  720. #else

  721. 

  722. JSList *

  723. jack_internals_load (JSList * internals) {

  724.     struct dirent * dir_entry;

  725.     DIR * dir_stream;

  726.     const char * ptr;

  727.     int err;

  728.     JSList * driver_list = NULL;

  729.     jack_driver_desc_t * desc;

  730. 

  731.     const char* driver_dir;

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

  733.         driver_dir = ADDON_DIR;

  734.     }

  735. 

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

  737.     from the .so files in it */

  738.     dir_stream = opendir (driver_dir);

  739.     if (!dir_stream) {

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

  741.                     driver_dir, strerror (errno));

  742.         return NULL;

  743.     }

  744. 

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

  746. 

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

  748.         if (!ptr) {

  749.             continue;

  750.         }

  751.         ptr++;

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

  753.             continue;

  754.         }

  755.         

  756.         /* check if dll is an internal client */

  757.         if (!check_symbol(dir_entry->d_name, "jack_internal_initialize")) {

  758.              continue;

  759.         }

  760.   

  761.         desc = jack_get_descriptor (internals, dir_entry->d_name, "jack_get_descriptor");

  762.         if (desc) {

  763.             driver_list = jack_slist_append (driver_list, desc);

  764.         }

  765.     }

  766. 

  767.     err = closedir (dir_stream);

  768.     if (err) {

  769.         jack_error ("error closing internal directory %s: %s\n",

  770.                     driver_dir, strerror (errno));

  771.     }

  772. 

  773.     if (!driver_list) {

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

  775.         return NULL;

  776.     }

  777. 

  778.     return driver_list;

  779. }

  780. 

  781. #endif

  782. 

  783. jack_driver_info_t *

  784. jack_load_driver (jack_driver_desc_t * driver_desc) {

  785. #ifdef WIN32

  786.     int errstr;

  787. #else

  788.     const char * errstr;

  789. #endif

  790. 

  791.     jack_driver_info_t *info;

  792. 

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

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

  795. 

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

  797. #ifdef WIN32

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

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

  800.                         errstr);

  801. #else

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

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

  804.                         errstr);

  805. #endif

  806. 

  807.         } else {

  808.             jack_error ("bizarre error loading driver shared "

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

  810.         }

  811.         goto fail;

  812.     }

  813. 

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

  815. 

  816. #ifdef WIN32

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

  818. #else

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

  820. #endif

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

  822.                     driver_desc->file);

  823.         goto fail;

  824.     }

  825. 

  826.     return info;

  827. 

  828. fail:

  829.     if (info->handle) {

  830.         UnloadDriverModule(info->handle);

  831.     }

  832.     free (info);

  833.     return NULL;

  834. }