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

825 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. #include "JackDriverLoader.h"

  27. #include "JackConstants.h"

  28. #include "JackError.h"

  29. #include <getopt.h>

  30. #include <stdio.h>

  31. 

  32. #ifndef WIN32

  33. #include <dirent.h>

  34. #endif

  35. 

  36. #include <errno.h>

  37. 

  38. jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver_t * driver);

  39. 

  40. static void

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

  42. {

  43.     unsigned long i;

  44.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  45. 

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

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

  48.             case JackDriverParamInt:

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

  50.                 break;

  51.             case JackDriverParamUInt:

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

  53.                 break;

  54.             case JackDriverParamChar:

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

  56.                 break;

  57.             case JackDriverParamString:

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

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

  60.                 else

  61.                     sprintf (arg_default, "none");

  62.                 break;

  63.             case JackDriverParamBool:

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

  65.                 break;

  66.         }

  67. 

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

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

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

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

  72.                  arg_default);

  73.     }

  74. }

  75. 

  76. static void

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

  78. {

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

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

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

  82. }

  83. 

  84. SERVER_EXPORT void jack_free_driver_params(JSList * driver_params)

  85. {

  86.     JSList *node_ptr = driver_params;

  87.     JSList *next_node_ptr;

  88. 

  89.     while (node_ptr) {

  90.         next_node_ptr = node_ptr->next;

  91.         free(node_ptr->data);

  92.         free(node_ptr);

  93.         node_ptr = next_node_ptr;

  94.     }

  95. }

  96. 

  97. int

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

  99. {

  100.     struct option * long_options;

  101.     char * options, * options_ptr;

  102.     unsigned long i;

  103.     int opt;

  104.     unsigned int param_index;

  105.     JSList * params = NULL;

  106.     jack_driver_param_t * driver_param;

  107. 

  108.     if (argc <= 1) {

  109.         *param_ptr = NULL;

  110.         return 0;

  111.     }

  112. 

  113.     /* check for help */

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

  115.         if (argc > 2) {

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

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

  118.                     jack_print_driver_param_usage (desc, i, stdout);

  119.                     return 1;

  120.                 }

  121.             }

  122. 

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

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

  125.                      desc->name);

  126.         }

  127. 

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

  129.         jack_print_driver_options (desc, stdout);

  130.         return 1;

  131.     }

  132. 

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

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

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

  136. 

  137.     options_ptr = options;

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

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

  140.         options_ptr += 3;

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

  142.         long_options[i].flag = NULL;

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

  144.         long_options[i].has_arg = optional_argument;

  145.     }

  146. 

  147.     /* create the params */

  148.     optind = 0;

  149.     opterr = 0;

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

  151. 

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

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

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

  155.             } else {

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

  157.             }

  158. 

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

  160.             jack_print_driver_options (desc, stderr);

  161.             exit (1);

  162.         }

  163. 

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

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

  166.                 break;

  167.             }

  168.         }

  169. 

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

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

  172. 

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

  174.                 strlen(argv[optind]) &&

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

  176.             optarg = argv[optind];

  177.         }

  178. 

  179.         if (optarg) {

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

  181.                 case JackDriverParamInt:

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

  183.                     break;

  184.                 case JackDriverParamUInt:

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

  186.                     break;

  187.                 case JackDriverParamChar:

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

  189.                     break;

  190.                 case JackDriverParamString:

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

  192.                     break;

  193.                 case JackDriverParamBool:

  194. 

  195.                     /*

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

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

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

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

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

  201.                     */

  202.                     // steph

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

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

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

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

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

  208.                         driver_param->value.i = false;

  209. 

  210.                     } else {

  211. 

  212.                         driver_param->value.i = true;

  213. 

  214.                     }

  215.                     break;

  216.             }

  217.         } else {

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

  219.                 driver_param->value.i = true;

  220.             } else {

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

  222.             }

  223.         }

  224. 

  225.         params = jack_slist_append (params, driver_param);

  226.     }

  227. 

  228.     free (options);

  229.     free (long_options);

  230. 

  231.     if (param_ptr)

  232.         *param_ptr = params;

  233. 

  234.     return 0;

  235. }

  236. 

  237. SERVER_EXPORT int

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

  239. {

  240.     struct option * long_options;

  241.     char * options, * options_ptr;

  242.     unsigned long i;

  243.     int opt;

  244.     JSList * node_ptr;

  245.     jackctl_parameter_t * param = NULL;

  246.     union jackctl_parameter_value value;

  247. 

  248.     if (argc <= 1)

  249.         return 0;

  250. 

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

  252.     if (driver_params == NULL)

  253.         return 1;

  254. 

  255.     jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);

  256. 

  257.     /* check for help */

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

  259.         if (argc > 2) {

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

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

  262.                     jack_print_driver_param_usage (desc, i, stdout);

  263.                     return 1;

  264.                 }

  265.             }

  266. 

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

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

  269.                      desc->name);

  270.         }

  271. 

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

  273.         jack_print_driver_options (desc, stdout);

  274.         return 1;

  275.     }

  276. 

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

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

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

  280. 

  281.     options_ptr = options;

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

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

  284.         options_ptr += 3;

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

  286.         long_options[i].flag = NULL;

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

  288.         long_options[i].has_arg = optional_argument;

  289.     }

  290. 

  291.     /* create the params */

  292.     optind = 0;

  293.     opterr = 0;

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

  295. 

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

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

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

  299.             } else {

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

  301.             }

  302. 

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

  304.             jack_print_driver_options(desc, stderr);

  305.             return 1;

  306.         }

  307. 

  308.         node_ptr = (JSList *)driver_params;

  309.        	while (node_ptr) {

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

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

  312.                 break;

  313.             }

  314.             node_ptr = node_ptr->next;

  315.         }

  316. 

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

  318.             strlen(argv[optind]) &&

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

  320.             optarg = argv[optind];

  321.         }

  322. 

  323.         if (optarg) {

  324.             switch (jackctl_parameter_get_type(param)) {

  325.                 case JackDriverParamInt:

  326.                     value.i = atoi (optarg);

  327.                     jackctl_parameter_set_value(param, &value);

  328.                     break;

  329.                 case JackDriverParamUInt:

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

  331.                     jackctl_parameter_set_value(param, &value);

  332.                     break;

  333.                 case JackDriverParamChar:

  334.                     value.c = optarg[0];

  335.                     jackctl_parameter_set_value(param, &value);

  336.                     break;

  337.                 case JackDriverParamString:

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

  339.                     jackctl_parameter_set_value(param, &value);

  340.                     break;

  341.                 case JackDriverParamBool:

  342.                     /*

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

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

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

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

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

  348.                     */

  349.                     // steph

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

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

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

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

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

  355.                         value.i = false;

  356.                     } else {

  357.                         value.i = true;

  358.                     }

  359.                     jackctl_parameter_set_value(param, &value);

  360.                     break;

  361.             }

  362.         } else {

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

  364.                 value.i = true;

  365.             } else {

  366.                 value = jackctl_parameter_get_default_value(param);

  367.             }

  368.             jackctl_parameter_set_value(param, &value);

  369.         }

  370.     }

  371. 

  372.     free(options);

  373.     free(long_options);

  374.     return 0;

  375. }

  376. 

  377. jack_driver_desc_t *

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

  379. {

  380.     jack_driver_desc_t * desc = 0;

  381.     JSList * node;

  382. 

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

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

  385. 

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

  387.             desc = NULL;

  388.         } else {

  389.             break;

  390.         }

  391.     }

  392. 

  393.     return desc;

  394. }

  395. 

  396. static jack_driver_desc_t *

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

  398. {

  399.     jack_driver_desc_t * descriptor, * other_descriptor;

  400.     JackDriverDescFunction so_get_descriptor = NULL;

  401.     JSList * node;

  402.     void * dlhandle;

  403.     char * filename;

  404. #ifdef WIN32

  405.     int dlerr;

  406. #else

  407.     const char * dlerr;

  408. #endif

  409. 

  410.     int err;

  411.     const char* driver_dir;

  412. 

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

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

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

  416. #ifdef WIN32

  417.         char temp_driver_dir1[512];

  418.         char temp_driver_dir2[512];

  419.         GetCurrentDirectory(512, temp_driver_dir1);

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

  421.         driver_dir = temp_driver_dir2;

  422. #else

  423.         driver_dir = ADDON_DIR;

  424. #endif

  425.     }

  426. 

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

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

  429. 

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

  431. #ifdef WIN32

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

  433. #else

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

  435. #endif

  436. 

  437.         free(filename);

  438.         return NULL;

  439.     }

  440. 

  441.     so_get_descriptor = (JackDriverDescFunction)

  442.                         GetProc(dlhandle, symbol);

  443. 

  444. #ifdef WIN32

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

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

  447. #else

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

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

  450. #endif

  451. 

  452.         UnloadDriverModule(dlhandle);

  453.         free(filename);

  454.         return NULL;

  455.     }

  456. 

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

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

  459.         UnloadDriverModule(dlhandle);

  460.         free(filename);

  461.         return NULL;

  462.     }

  463. 

  464. #ifdef WIN32

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

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

  467.     }

  468. #else

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

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

  471.     }

  472. #endif

  473. 

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

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

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

  477. 

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

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

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

  481.             /* FIXME: delete the descriptor */

  482.             free(filename);

  483.             return NULL;

  484.         }

  485.     }

  486. 

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

  488.     free(filename);

  489.     return descriptor;

  490. }

  491. 

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

  493. {

  494.     void * dlhandle;

  495.     bool res = false;

  496.     const char* driver_dir;

  497. 

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

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

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

  501. #ifdef WIN32

  502.         char temp_driver_dir1[512];

  503.         char temp_driver_dir2[512];

  504.         GetCurrentDirectory(512, temp_driver_dir1);

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

  506.         driver_dir = temp_driver_dir2;

  507. #else

  508.         driver_dir = ADDON_DIR;

  509. #endif

  510.     }

  511. 

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

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

  514. 

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

  516. #ifdef WIN32

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

  518. #else

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

  520. #endif

  521.      } else {

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

  523.         UnloadDriverModule(dlhandle);

  524.     }

  525. 

  526.     free(filename);

  527.     return res;

  528. }

  529. 

  530. #ifdef WIN32

  531. 

  532. JSList *

  533. jack_drivers_load (JSList * drivers) {

  534.     char * driver_dir;

  535.     char driver_dir_storage[512];

  536.     char dll_filename[512];

  537.     WIN32_FIND_DATA filedata;

  538.     HANDLE file;

  539.     const char * ptr = NULL;

  540.     JSList * driver_list = NULL;

  541.     jack_driver_desc_t * desc;

  542. 

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

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

  545.         GetCurrentDirectory(512, driver_dir_storage);

  546.         strcat(driver_dir_storage, "/");

  547.         strcat(driver_dir_storage, ADDON_DIR);

  548.         driver_dir = driver_dir_storage;

  549.     }

  550. 

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

  552. 

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

  554. 

  555.     if (file == INVALID_HANDLE_VALUE) {

  556.         jack_error("error invalid handle");

  557.         return NULL;

  558.     }

  559. 

  560.     do {

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

  562.         if (!ptr) {

  563.             continue;

  564.         }

  565.         ptr++;

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

  567.             continue;

  568.         }

  569. 

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

  571.         if (desc) {

  572.             driver_list = jack_slist_append (driver_list, desc);

  573.         }

  574. 

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

  576. 

  577.     if (!driver_list) {

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

  579.         return NULL;

  580.     }

  581. 

  582.     return driver_list;

  583. }

  584. 

  585. #else

  586. 

  587. JSList *

  588. jack_drivers_load (JSList * drivers) {

  589.     struct dirent * dir_entry;

  590.     DIR * dir_stream;

  591.     const char * ptr;

  592.     int err;

  593.     JSList * driver_list = NULL;

  594.     jack_driver_desc_t * desc;

  595. 

  596.     const char* driver_dir;

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

  598.         driver_dir = ADDON_DIR;

  599.     }

  600. 

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

  602.     from the .so files in it */

  603.     dir_stream = opendir (driver_dir);

  604.     if (!dir_stream) {

  605.         jack_error ("could not open driver directory %s: %s",

  606.                     driver_dir, strerror (errno));

  607.         return NULL;

  608.     }

  609. 

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

  611. 

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

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

  614.             continue;

  615.         }

  616. 

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

  618.         if (!ptr) {

  619.             continue;

  620.         }

  621.         ptr++;

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

  623.             continue;

  624.         }

  625. 

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

  627.         if (desc) {

  628.             driver_list = jack_slist_append (driver_list, desc);

  629.         }

  630.     }

  631. 

  632.     err = closedir (dir_stream);

  633.     if (err) {

  634.         jack_error ("error closing driver directory %s: %s",

  635.                     driver_dir, strerror (errno));

  636.     }

  637. 

  638.     if (!driver_list) {

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

  640.         return NULL;

  641.     }

  642. 

  643.     return driver_list;

  644. }

  645. 

  646. #endif

  647. 

  648. #ifdef WIN32

  649. 

  650. JSList *

  651. jack_internals_load (JSList * internals) {

  652.     char * driver_dir;

  653.     char driver_dir_storage[512];

  654.     char dll_filename[512];

  655.     WIN32_FIND_DATA filedata;

  656.     HANDLE file;

  657.     const char * ptr = NULL;

  658.     JSList * driver_list = NULL;

  659.     jack_driver_desc_t * desc;

  660. 

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

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

  663.         GetCurrentDirectory(512, driver_dir_storage);

  664.         strcat(driver_dir_storage, "/");

  665.         strcat(driver_dir_storage, ADDON_DIR);

  666.         driver_dir = driver_dir_storage;

  667.     }

  668. 

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

  670. 

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

  672. 

  673.     if (file == INVALID_HANDLE_VALUE) {

  674.         jack_error("error");

  675.         return NULL;

  676.     }

  677. 

  678.     do {

  679. 

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

  681.         if (!ptr) {

  682.             continue;

  683.         }

  684.         ptr++;

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

  686.             continue;

  687.         }

  688. 

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

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

  691.              continue;

  692.         }

  693. 

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

  695.         if (desc) {

  696.             driver_list = jack_slist_append (driver_list, desc);

  697.         }

  698. 

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

  700. 

  701.     if (!driver_list) {

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

  703.         return NULL;

  704.     }

  705. 

  706.     return driver_list;

  707. }

  708. 

  709. #else

  710. 

  711. JSList *

  712. jack_internals_load (JSList * internals) {

  713.     struct dirent * dir_entry;

  714.     DIR * dir_stream;

  715.     const char * ptr;

  716.     int err;

  717.     JSList * driver_list = NULL;

  718.     jack_driver_desc_t * desc;

  719. 

  720.     const char* driver_dir;

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

  722.         driver_dir = ADDON_DIR;

  723.     }

  724. 

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

  726.     from the .so files in it */

  727.     dir_stream = opendir (driver_dir);

  728.     if (!dir_stream) {

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

  730.                     driver_dir, strerror (errno));

  731.         return NULL;

  732.     }

  733. 

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

  735. 

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

  737.         if (!ptr) {

  738.             continue;

  739.         }

  740.         ptr++;

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

  742.             continue;

  743.         }

  744. 

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

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

  747.              continue;

  748.         }

  749. 

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

  751.         if (desc) {

  752.             driver_list = jack_slist_append (driver_list, desc);

  753.         }

  754.     }

  755. 

  756.     err = closedir (dir_stream);

  757.     if (err) {

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

  759.                     driver_dir, strerror (errno));

  760.     }

  761. 

  762.     if (!driver_list) {

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

  764.         return NULL;

  765.     }

  766. 

  767.     return driver_list;

  768. }

  769. 

  770. #endif

  771. 

  772. jack_driver_info_t *

  773. jack_load_driver (jack_driver_desc_t * driver_desc) {

  774. #ifdef WIN32

  775.     int errstr;

  776. #else

  777.     const char * errstr;

  778. #endif

  779. 

  780.     jack_driver_info_t *info;

  781. 

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

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

  784. 

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

  786. #ifdef WIN32

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

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

  789.                         errstr);

  790. #else

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

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

  793.                         errstr);

  794. #endif

  795. 

  796.         } else {

  797.             jack_error ("bizarre error loading driver shared "

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

  799.         }

  800.         goto fail;

  801.     }

  802. 

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

  804. 

  805. #ifdef WIN32

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

  807. #else

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

  809. #endif

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

  811.                     driver_desc->file);

  812.         goto fail;

  813.     }

  814. 

  815.     return info;

  816. 

  817. fail:

  818.     if (info->handle) {

  819.         UnloadDriverModule(info->handle);

  820.     }

  821.     free (info);

  822.     return NULL;

  823. }