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

834 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. #include "JackSystemDeps.h"

  26. 

  27. /*

  28. #ifndef WIN32

  29. #ifndef ADDON_DIR

  30. #include "config.h"

  31. #endif

  32. #endif

  33. */

  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. SERVER_EXPORT void jack_free_driver_params(JSList * driver_params)

  94. {

  95.     JSList *node_ptr = driver_params;

  96.     JSList *next_node_ptr;

  97. 

  98.     while (node_ptr) {

  99.         next_node_ptr = node_ptr->next;

  100.         free(node_ptr->data);

  101.         free(node_ptr);

  102.         node_ptr = next_node_ptr;

  103.     }

  104. }

  105. 

  106. int

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

  108. {

  109.     struct option * long_options;

  110.     char * options, * options_ptr;

  111.     unsigned long i;

  112.     int opt;

  113.     unsigned int param_index;

  114.     JSList * params = NULL;

  115.     jack_driver_param_t * driver_param;

  116. 

  117.     if (argc <= 1) {

  118.         *param_ptr = NULL;

  119.         return 0;

  120.     }

  121. 

  122.     /* check for help */

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

  124.         if (argc > 2) {

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

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

  127.                     jack_print_driver_param_usage (desc, i, stdout);

  128.                     return 1;

  129.                 }

  130.             }

  131. 

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

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

  134.                      desc->name);

  135.         }

  136. 

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

  138.         jack_print_driver_options (desc, stdout);

  139.         return 1;

  140.     }

  141. 

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

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

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

  145. 

  146.     options_ptr = options;

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

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

  149.         options_ptr += 3;

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

  151.         long_options[i].flag = NULL;

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

  153.         long_options[i].has_arg = optional_argument;

  154.     }

  155. 

  156.     /* create the params */

  157.     optind = 0;

  158.     opterr = 0;

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

  160. 

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

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

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

  164.             } else {

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

  166.             }

  167. 

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

  169.             jack_print_driver_options (desc, stderr);

  170.             exit (1);

  171.         }

  172. 

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

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

  175.                 break;

  176.             }

  177.         }

  178. 

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

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

  181. 

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

  183.                 strlen(argv[optind]) &&

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

  185.             optarg = argv[optind];

  186.         }

  187. 

  188.         if (optarg) {

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

  190.                 case JackDriverParamInt:

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

  192.                     break;

  193.                 case JackDriverParamUInt:

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

  195.                     break;

  196.                 case JackDriverParamChar:

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

  198.                     break;

  199.                 case JackDriverParamString:

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

  201.                     break;

  202.                 case JackDriverParamBool:

  203. 

  204.                     /*

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

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

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

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

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

  210.                     */

  211.                     // steph

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

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

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

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

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

  217.                         driver_param->value.i = false;

  218. 

  219.                     } else {

  220. 

  221.                         driver_param->value.i = true;

  222. 

  223.                     }

  224.                     break;

  225.             }

  226.         } else {

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

  228.                 driver_param->value.i = true;

  229.             } else {

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

  231.             }

  232.         }

  233. 

  234.         params = jack_slist_append (params, driver_param);

  235.     }

  236. 

  237.     free (options);

  238.     free (long_options);

  239. 

  240.     if (param_ptr)

  241.         *param_ptr = params;

  242. 

  243.     return 0;

  244. }

  245. 

  246. SERVER_EXPORT int

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

  248. {

  249.     struct option * long_options;

  250.     char * options, * options_ptr;

  251.     unsigned long i;

  252.     int opt;

  253.     JSList * node_ptr;

  254.     jackctl_parameter_t * param = NULL;

  255.     union jackctl_parameter_value value;

  256. 

  257.     if (argc <= 1)

  258.         return 0;

  259. 

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

  261.     if (driver_params == NULL)

  262.         return 1;

  263. 

  264.     jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);

  265. 

  266.     /* check for help */

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

  268.         if (argc > 2) {

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

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

  271.                     jack_print_driver_param_usage (desc, i, stdout);

  272.                     return 1;

  273.                 }

  274.             }

  275. 

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

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

  278.                      desc->name);

  279.         }

  280. 

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

  282.         jack_print_driver_options (desc, stdout);

  283.         return 1;

  284.     }

  285. 

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

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

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

  289. 

  290.     options_ptr = options;

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

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

  293.         options_ptr += 3;

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

  295.         long_options[i].flag = NULL;

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

  297.         long_options[i].has_arg = optional_argument;

  298.     }

  299. 

  300.     /* create the params */

  301.     optind = 0;

  302.     opterr = 0;

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

  304. 

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

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

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

  308.             } else {

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

  310.             }

  311. 

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

  313.             jack_print_driver_options(desc, stderr);

  314.             return 1;

  315.         }

  316. 

  317.         node_ptr = (JSList *)driver_params;

  318.        	while (node_ptr) {

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

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

  321.                 break;

  322.             }

  323.             node_ptr = node_ptr->next;

  324.         }

  325. 

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

  327.             strlen(argv[optind]) &&

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

  329.             optarg = argv[optind];

  330.         }

  331. 

  332.         if (optarg) {

  333.             switch (jackctl_parameter_get_type(param)) {

  334.                 case JackDriverParamInt:

  335.                     value.i = atoi (optarg);

  336.                     jackctl_parameter_set_value(param, &value);

  337.                     break;

  338.                 case JackDriverParamUInt:

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

  340.                     jackctl_parameter_set_value(param, &value);

  341.                     break;

  342.                 case JackDriverParamChar:

  343.                     value.c = optarg[0];

  344.                     jackctl_parameter_set_value(param, &value);

  345.                     break;

  346.                 case JackDriverParamString:

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

  348.                     jackctl_parameter_set_value(param, &value);

  349.                     break;

  350.                 case JackDriverParamBool:

  351.                     /*

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

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

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

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

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

  357.                     */

  358.                     // steph

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

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

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

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

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

  364.                         value.i = false;

  365.                     } else {

  366.                         value.i = true;

  367.                     }

  368.                     jackctl_parameter_set_value(param, &value);

  369.                     break;

  370.             }

  371.         } else {

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

  373.                 value.i = true;

  374.             } else {

  375.                 value = jackctl_parameter_get_default_value(param);

  376.             }

  377.             jackctl_parameter_set_value(param, &value);

  378.         }

  379.     }

  380. 

  381.     free(options);

  382.     free(long_options);

  383.     return 0;

  384. }

  385. 

  386. jack_driver_desc_t *

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

  388. {

  389.     jack_driver_desc_t * desc = 0;

  390.     JSList * node;

  391. 

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

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

  394. 

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

  396.             desc = NULL;

  397.         } else {

  398.             break;

  399.         }

  400.     }

  401. 

  402.     return desc;

  403. }

  404. 

  405. static jack_driver_desc_t *

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

  407. {

  408.     jack_driver_desc_t * descriptor, * other_descriptor;

  409.     JackDriverDescFunction so_get_descriptor = NULL;

  410.     JSList * node;

  411.     void * dlhandle;

  412.     char * filename;

  413. #ifdef WIN32

  414.     int dlerr;

  415. #else

  416.     const char * dlerr;

  417. #endif

  418. 

  419.     int err;

  420.     const char* driver_dir;

  421. 

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

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

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

  425. #ifdef WIN32

  426.         char temp_driver_dir1[512];

  427.         char temp_driver_dir2[512];

  428.         GetCurrentDirectory(512, temp_driver_dir1);

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

  430.         driver_dir = temp_driver_dir2;

  431. #else

  432.         driver_dir = ADDON_DIR;

  433. #endif

  434.     }

  435. 

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

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

  438. 

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

  440. #ifdef WIN32

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

  442. #else

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

  444. #endif

  445. 

  446.         free(filename);

  447.         return NULL;

  448.     }

  449. 

  450.     so_get_descriptor = (JackDriverDescFunction)

  451.                         GetProc(dlhandle, symbol);

  452. 

  453. #ifdef WIN32

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

  455.         jack_log("jack_get_descriptor : dll is not a driver, err = %ld", dlerr);

  456. #else

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

  458.         jack_log("jack_get_descriptor err = %s", dlerr);

  459. #endif

  460. 

  461.         UnloadDriverModule(dlhandle);

  462.         free(filename);

  463.         return NULL;

  464.     }

  465. 

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

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

  468.         UnloadDriverModule(dlhandle);

  469.         free(filename);

  470.         return NULL;

  471.     }

  472. 

  473. #ifdef WIN32

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

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

  476.     }

  477. #else

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

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

  480.     }

  481. #endif

  482. 

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

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

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

  486. 

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

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

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

  490.             /* FIXME: delete the descriptor */

  491.             free(filename);

  492.             return NULL;

  493.         }

  494.     }

  495. 

  496.     strncpy(descriptor->file, filename, JACK_PATH_MAX);

  497.     free(filename);

  498.     return descriptor;

  499. }

  500. 

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

  502. {

  503.     void * dlhandle;

  504.     bool res = false;

  505.     const char* driver_dir;

  506. 

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

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

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

  510. #ifdef WIN32

  511.         char temp_driver_dir1[512];

  512.         char temp_driver_dir2[512];

  513.         GetCurrentDirectory(512, temp_driver_dir1);

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

  515.         driver_dir = temp_driver_dir2;

  516. #else

  517.         driver_dir = ADDON_DIR;

  518. #endif

  519.     }

  520. 

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

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

  523. 

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

  525. #ifdef WIN32

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

  527. #else

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

  529. #endif

  530.      } else {

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

  532.         UnloadDriverModule(dlhandle);

  533.     }

  534. 

  535.     free(filename);

  536.     return res;

  537. }

  538. 

  539. #ifdef WIN32

  540. 

  541. JSList *

  542. jack_drivers_load (JSList * drivers) {

  543.     char * driver_dir;

  544.     char driver_dir_storage[512];

  545.     char dll_filename[512];

  546.     WIN32_FIND_DATA filedata;

  547.     HANDLE file;

  548.     const char * ptr = NULL;

  549.     JSList * driver_list = NULL;

  550.     jack_driver_desc_t * desc;

  551. 

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

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

  554.         GetCurrentDirectory(512, driver_dir_storage);

  555.         strcat(driver_dir_storage, "/");

  556.         strcat(driver_dir_storage, ADDON_DIR);

  557.         driver_dir = driver_dir_storage;

  558.     }

  559. 

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

  561. 

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

  563. 

  564.     if (file == INVALID_HANDLE_VALUE) {

  565.         jack_error("error");

  566.         return NULL;

  567.     }

  568. 

  569.     do {

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

  571.         if (!ptr) {

  572.             continue;

  573.         }

  574.         ptr++;

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

  576.             continue;

  577.         }

  578. 

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

  580.         if (desc) {

  581.             driver_list = jack_slist_append (driver_list, desc);

  582.         }

  583. 

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

  585. 

  586.     if (!driver_list) {

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

  588.         return NULL;

  589.     }

  590. 

  591.     return driver_list;

  592. }

  593. 

  594. #else

  595. 

  596. JSList *

  597. jack_drivers_load (JSList * drivers) {

  598.     struct dirent * dir_entry;

  599.     DIR * dir_stream;

  600.     const char * ptr;

  601.     int err;

  602.     JSList * driver_list = NULL;

  603.     jack_driver_desc_t * desc;

  604. 

  605.     const char* driver_dir;

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

  607.         driver_dir = ADDON_DIR;

  608.     }

  609. 

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

  611.     from the .so files in it */

  612.     dir_stream = opendir (driver_dir);

  613.     if (!dir_stream) {

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

  615.                     driver_dir, strerror (errno));

  616.         return NULL;

  617.     }

  618. 

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

  620. 

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

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

  623.             continue;

  624.         }

  625. 

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

  627.         if (!ptr) {

  628.             continue;

  629.         }

  630.         ptr++;

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

  632.             continue;

  633.         }

  634. 

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

  636.         if (desc) {

  637.             driver_list = jack_slist_append (driver_list, desc);

  638.         }

  639.     }

  640. 

  641.     err = closedir (dir_stream);

  642.     if (err) {

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

  644.                     driver_dir, strerror (errno));

  645.     }

  646. 

  647.     if (!driver_list) {

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

  649.         return NULL;

  650.     }

  651. 

  652.     return driver_list;

  653. }

  654. 

  655. #endif

  656. 

  657. #ifdef WIN32

  658. 

  659. JSList *

  660. jack_internals_load (JSList * internals) {

  661.     char * driver_dir;

  662.     char driver_dir_storage[512];

  663.     char dll_filename[512];

  664.     WIN32_FIND_DATA filedata;

  665.     HANDLE file;

  666.     const char * ptr = NULL;

  667.     JSList * driver_list = NULL;

  668.     jack_driver_desc_t * desc;

  669. 

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

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

  672.         GetCurrentDirectory(512, driver_dir_storage);

  673.         strcat(driver_dir_storage, "/");

  674.         strcat(driver_dir_storage, ADDON_DIR);

  675.         driver_dir = driver_dir_storage;

  676.     }

  677. 

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

  679. 

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

  681. 

  682.     if (file == INVALID_HANDLE_VALUE) {

  683.         jack_error("error");

  684.         return NULL;

  685.     }

  686. 

  687.     do {

  688. 

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

  690.         if (!ptr) {

  691.             continue;

  692.         }

  693.         ptr++;

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

  695.             continue;

  696.         }

  697. 

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

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

  700.              continue;

  701.         }

  702. 

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

  704.         if (desc) {

  705.             driver_list = jack_slist_append (driver_list, desc);

  706.         }

  707. 

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

  709. 

  710.     if (!driver_list) {

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

  712.         return NULL;

  713.     }

  714. 

  715.     return driver_list;

  716. }

  717. 

  718. #else

  719. 

  720. JSList *

  721. jack_internals_load (JSList * internals) {

  722.     struct dirent * dir_entry;

  723.     DIR * dir_stream;

  724.     const char * ptr;

  725.     int err;

  726.     JSList * driver_list = NULL;

  727.     jack_driver_desc_t * desc;

  728. 

  729.     const char* driver_dir;

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

  731.         driver_dir = ADDON_DIR;

  732.     }

  733. 

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

  735.     from the .so files in it */

  736.     dir_stream = opendir (driver_dir);

  737.     if (!dir_stream) {

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

  739.                     driver_dir, strerror (errno));

  740.         return NULL;

  741.     }

  742. 

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

  744. 

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

  746.         if (!ptr) {

  747.             continue;

  748.         }

  749.         ptr++;

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

  751.             continue;

  752.         }

  753. 

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

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

  756.              continue;

  757.         }

  758. 

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

  760.         if (desc) {

  761.             driver_list = jack_slist_append (driver_list, desc);

  762.         }

  763.     }

  764. 

  765.     err = closedir (dir_stream);

  766.     if (err) {

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

  768.                     driver_dir, strerror (errno));

  769.     }

  770. 

  771.     if (!driver_list) {

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

  773.         return NULL;

  774.     }

  775. 

  776.     return driver_list;

  777. }

  778. 

  779. #endif

  780. 

  781. jack_driver_info_t *

  782. jack_load_driver (jack_driver_desc_t * driver_desc) {

  783. #ifdef WIN32

  784.     int errstr;

  785. #else

  786.     const char * errstr;

  787. #endif

  788. 

  789.     jack_driver_info_t *info;

  790. 

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

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

  793. 

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

  795. #ifdef WIN32

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

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

  798.                         errstr);

  799. #else

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

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

  802.                         errstr);

  803. #endif

  804. 

  805.         } else {

  806.             jack_error ("bizarre error loading driver shared "

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

  808.         }

  809.         goto fail;

  810.     }

  811. 

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

  813. 

  814. #ifdef WIN32

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

  816. #else

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

  818. #endif

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

  820.                     driver_desc->file);

  821.         goto fail;

  822.     }

  823. 

  824.     return info;

  825. 

  826. fail:

  827.     if (info->handle) {

  828.         UnloadDriverModule(info->handle);

  829.     }

  830.     free (info);

  831.     return NULL;

  832. }