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

837 lines
25KB
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. #include "JackSystemDeps.h"

  22. #include "JackDriverLoader.h"

  23. #include "JackConstants.h"

  24. #include "JackError.h"

  25. #include <getopt.h>

  26. #include <stdio.h>

  27. #include <errno.h>

  28. 

  29. #ifndef WIN32

  30. #include <dirent.h>

  31. #endif

  32. 

  33. jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver_t * driver);

  34. 

  35. EXPORT void jack_print_driver_options (jack_driver_desc_t* desc, FILE* file)

  36. {

  37.     unsigned long i;

  38.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  39. 

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

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

  42.             case JackDriverParamInt:

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

  44.                 break;

  45.             case JackDriverParamUInt:

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

  47.                 break;

  48.             case JackDriverParamChar:

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

  50.                 break;

  51.             case JackDriverParamString:

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

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

  54.                 else

  55.                     sprintf (arg_default, "none");

  56.                 break;

  57.             case JackDriverParamBool:

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

  59.                 break;

  60.         }

  61. 

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

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

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

  65.                  desc->params[i].long_desc,

  66.                  arg_default);

  67.     }

  68. }

  69. 

  70. static void

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

  72. {

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

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

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

  76. }

  77. 

  78. EXPORT void jack_free_driver_params(JSList * driver_params)

  79. {

  80.     JSList *node_ptr = driver_params;

  81.     JSList *next_node_ptr;

  82. 

  83.     while (node_ptr) {

  84.         next_node_ptr = node_ptr->next;

  85.         free(node_ptr->data);

  86.         free(node_ptr);

  87.         node_ptr = next_node_ptr;

  88.     }

  89. }

  90. 

  91. int

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

  93. {

  94.     struct option * long_options;

  95.     char * options, * options_ptr;

  96.     unsigned long i;

  97.     int opt;

  98.     unsigned int param_index;

  99.     JSList * params = NULL;

  100.     jack_driver_param_t * driver_param;

  101. 

  102.     if (argc <= 1) {

  103.         *param_ptr = NULL;

  104.         return 0;

  105.     }

  106. 

  107.     /* check for help */

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

  109.         if (argc > 2) {

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

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

  112.                     jack_print_driver_param_usage (desc, i, stdout);

  113.                     return 1;

  114.                 }

  115.             }

  116. 

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

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

  119.                      desc->name);

  120.         }

  121. 

  122.         jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);

  123.         jack_print_driver_options (desc, stdout);

  124.         return 1;

  125.     }

  126. 

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

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

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

  130. 

  131.     options_ptr = options;

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

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

  134.         options_ptr += 3;

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

  136.         long_options[i].flag = NULL;

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

  138.         long_options[i].has_arg = optional_argument;

  139.     }

  140. 

  141.     /* create the params */

  142.     optind = 0;

  143.     opterr = 0;

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

  145. 

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

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

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

  149.             } else {

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

  151.             }

  152. 

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

  154.             jack_print_driver_options (desc, stderr);

  155.             return 1;

  156.         }

  157. 

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

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

  160.                 break;

  161.             }

  162.         }

  163. 

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

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

  166. 

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

  168.                 strlen(argv[optind]) &&

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

  170.             optarg = argv[optind];

  171.         }

  172. 

  173.         if (optarg) {

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

  175.                 case JackDriverParamInt:

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

  177.                     break;

  178.                 case JackDriverParamUInt:

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

  180.                     break;

  181.                 case JackDriverParamChar:

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

  183.                     break;

  184.                 case JackDriverParamString:

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

  186.                     break;

  187.                 case JackDriverParamBool:

  188. 

  189.                     /*

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

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

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

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

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

  195.                     */

  196.                     // steph

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

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

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

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

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

  202.                         driver_param->value.i = false;

  203. 

  204.                     } else {

  205. 

  206.                         driver_param->value.i = true;

  207. 

  208.                     }

  209.                     break;

  210.             }

  211.         } else {

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

  213.                 driver_param->value.i = true;

  214.             } else {

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

  216.             }

  217.         }

  218. 

  219.         params = jack_slist_append (params, driver_param);

  220.     }

  221. 

  222.     free (options);

  223.     free (long_options);

  224. 

  225.     if (param_ptr)

  226.         *param_ptr = params;

  227. 

  228.     return 0;

  229. }

  230. 

  231. EXPORT int

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

  233. {

  234.     struct option * long_options;

  235.     char * options, * options_ptr;

  236.     unsigned long i;

  237.     int opt;

  238.     JSList * node_ptr;

  239.     jackctl_parameter_t * param = NULL;

  240.     union jackctl_parameter_value value;

  241. 

  242.     if (argc <= 1)

  243.         return 0;

  244. 

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

  246.     if (driver_params == NULL)

  247.         return 1;

  248. 

  249.     jack_driver_desc_t * desc = jackctl_driver_get_desc(driver_ptr);

  250. 

  251.     /* check for help */

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

  253.         if (argc > 2) {

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

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

  256.                     jack_print_driver_param_usage (desc, i, stdout);

  257.                     return 1;

  258.                 }

  259.             }

  260. 

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

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

  263.                      desc->name);

  264.         }

  265. 

  266.         jack_log("Parameters for driver '%s' (all parameters are optional):", desc->name);

  267.         jack_print_driver_options (desc, stdout);

  268.         return 1;

  269.     }

  270. 

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

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

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

  274. 

  275.     options_ptr = options;

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

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

  278.         options_ptr += 3;

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

  280.         long_options[i].flag = NULL;

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

  282.         long_options[i].has_arg = optional_argument;

  283.     }

  284. 

  285.     /* create the params */

  286.     optind = 0;

  287.     opterr = 0;

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

  289. 

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

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

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

  293.             } else {

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

  295.             }

  296. 

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

  298.             jack_print_driver_options(desc, stderr);

  299.             return 1;

  300.         }

  301. 

  302.         node_ptr = (JSList *)driver_params;

  303.        	while (node_ptr) {

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

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

  306.                 break;

  307.             }

  308.             node_ptr = node_ptr->next;

  309.         }

  310. 

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

  312.             strlen(argv[optind]) &&

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

  314.             optarg = argv[optind];

  315.         }

  316. 

  317.         if (optarg) {

  318.             switch (jackctl_parameter_get_type(param)) {

  319.                 case JackDriverParamInt:

  320.                     value.i = atoi (optarg);

  321.                     jackctl_parameter_set_value(param, &value);

  322.                     break;

  323.                 case JackDriverParamUInt:

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

  325.                     jackctl_parameter_set_value(param, &value);

  326.                     break;

  327.                 case JackDriverParamChar:

  328.                     value.c = optarg[0];

  329.                     jackctl_parameter_set_value(param, &value);

  330.                     break;

  331.                 case JackDriverParamString:

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

  333.                     jackctl_parameter_set_value(param, &value);

  334.                     break;

  335.                 case JackDriverParamBool:

  336.                     /*

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

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

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

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

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

  342.                     */

  343.                     // steph

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

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

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

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

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

  349.                         value.i = false;

  350.                     } else {

  351.                         value.i = true;

  352.                     }

  353.                     jackctl_parameter_set_value(param, &value);

  354.                     break;

  355.             }

  356.         } else {

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

  358.                 value.i = true;

  359.             } else {

  360.                 value = jackctl_parameter_get_default_value(param);

  361.             }

  362.             jackctl_parameter_set_value(param, &value);

  363.         }

  364.     }

  365. 

  366.     free(options);

  367.     free(long_options);

  368.     return 0;

  369. }

  370. 

  371. jack_driver_desc_t *

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

  373. {

  374.     jack_driver_desc_t * desc = 0;

  375.     JSList * node;

  376. 

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

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

  379. 

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

  381.             desc = NULL;

  382.         } else {

  383.             break;

  384.         }

  385.     }

  386. 

  387.     return desc;

  388. }

  389. 

  390. static jack_driver_desc_t *

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

  392. {

  393.     jack_driver_desc_t * descriptor, * other_descriptor;

  394.     JackDriverDescFunction so_get_descriptor = NULL;

  395.     JSList * node;

  396.     void * dlhandle;

  397.     char * filename;

  398. #ifdef WIN32

  399.     int dlerr;

  400. #else

  401.     const char * dlerr;

  402. #endif

  403. 

  404.     int err;

  405.     const char* driver_dir;

  406. 

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

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

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

  410. #ifdef WIN32

  411.         char temp_driver_dir1[512];

  412.         char temp_driver_dir2[512];

  413.         GetCurrentDirectory(512, temp_driver_dir1);

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

  415.         driver_dir = temp_driver_dir2;

  416. #else

  417.         driver_dir = ADDON_DIR;

  418. #endif

  419.     }

  420. 

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

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

  423. 

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

  425. #ifdef WIN32

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

  427. #else

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

  429. #endif

  430. 

  431.         free(filename);

  432.         return NULL;

  433.     }

  434. 

  435.     so_get_descriptor = (JackDriverDescFunction)GetDriverProc(dlhandle, symbol);

  436. 

  437. #ifdef WIN32

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

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

  440. #else

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

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

  443. #endif

  444. 

  445.         UnloadDriverModule(dlhandle);

  446.         free(filename);

  447.         return NULL;

  448.     }

  449. 

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

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

  452.         UnloadDriverModule(dlhandle);

  453.         free(filename);

  454.         return NULL;

  455.     }

  456. 

  457. #ifdef WIN32

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

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

  460.     }

  461. #else

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

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

  464.     }

  465. #endif

  466. 

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

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

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

  470. 

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

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

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

  474.             /* FIXME: delete the descriptor */

  475.             free(filename);

  476.             return NULL;

  477.         }

  478.     }

  479. 

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

  481.     free(filename);

  482.     return descriptor;

  483. }

  484. 

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

  486. {

  487.     void * dlhandle;

  488.     bool res = false;

  489.     const char* driver_dir;

  490. 

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

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

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

  494. #ifdef WIN32

  495.         char temp_driver_dir1[512];

  496.         char temp_driver_dir2[512];

  497.         GetCurrentDirectory(512, temp_driver_dir1);

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

  499.         driver_dir = temp_driver_dir2;

  500. #else

  501.         driver_dir = ADDON_DIR;

  502. #endif

  503.     }

  504. 

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

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

  507. 

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

  509. #ifdef WIN32

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

  511. #else

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

  513. #endif

  514.      } else {

  515.         res = (GetDriverProc(dlhandle, symbol)) ? true : false;

  516.         UnloadDriverModule(dlhandle);

  517.     }

  518. 

  519.     free(filename);

  520.     return res;

  521. }

  522. 

  523. #ifdef WIN32

  524. 

  525. JSList *

  526. jack_drivers_load (JSList * drivers) {

  527.     char * driver_dir;

  528.     char driver_dir_storage[512];

  529.     char dll_filename[512];

  530.     WIN32_FIND_DATA filedata;

  531.     HANDLE file;

  532.     const char * ptr = NULL;

  533.     JSList * driver_list = NULL;

  534.     jack_driver_desc_t * desc = NULL;

  535. 

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

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

  538.         GetCurrentDirectory(512, driver_dir_storage);

  539.         strcat(driver_dir_storage, "/");

  540.         strcat(driver_dir_storage, ADDON_DIR);

  541.         driver_dir = driver_dir_storage;

  542.     }

  543. 

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

  545. 

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

  547. 

  548.     if (file == INVALID_HANDLE_VALUE) {

  549.         jack_error("error invalid handle");

  550.         return NULL;

  551.     }

  552. 

  553.     do {

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

  555.         if (strncmp ("jack_", filedata.cFileName, 5) != 0) {

  556.             continue;

  557.         }

  558. 

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

  560.         if (!ptr) {

  561.             continue;

  562.         }

  563.         ptr++;

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

  565.             continue;

  566.         }

  567. 

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

  569.         if (check_symbol(filedata.cFileName, "jack_internal_initialize")) {

  570.              continue;

  571.         }

  572. 

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

  574.         if (desc) {

  575.             driver_list = jack_slist_append (driver_list, desc);

  576.         } else {

  577.             jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);

  578.         }

  579. 

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

  581. 

  582.     if (!driver_list) {

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

  584.         return NULL;

  585.     }

  586. 

  587.     return driver_list;

  588. }

  589. 

  590. #else

  591. 

  592. JSList *

  593. jack_drivers_load (JSList * drivers) {

  594.     struct dirent * dir_entry;

  595.     DIR * dir_stream;

  596.     const char * ptr;

  597.     int err;

  598.     JSList * driver_list = NULL;

  599.     jack_driver_desc_t * desc = NULL;

  600. 

  601.     const char* driver_dir;

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

  603.         driver_dir = ADDON_DIR;

  604.     }

  605. 

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

  607.     from the .so files in it */

  608.     dir_stream = opendir (driver_dir);

  609.     if (!dir_stream) {

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

  611.                     driver_dir, strerror (errno));

  612.         return NULL;

  613.     }

  614. 

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

  616. 

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

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

  619.             continue;

  620.         }

  621. 

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

  623.         if (!ptr) {

  624.             continue;

  625.         }

  626.         ptr++;

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

  628.             continue;

  629.         }

  630. 

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

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

  633.              continue;

  634.         }

  635. 

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

  637.         if (desc) {

  638.             driver_list = jack_slist_append (driver_list, desc);

  639.         } else {

  640.             jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);

  641.         }

  642.     }

  643. 

  644.     err = closedir (dir_stream);

  645.     if (err) {

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

  647.                     driver_dir, strerror (errno));

  648.     }

  649. 

  650.     if (!driver_list) {

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

  652.         return NULL;

  653.     }

  654. 

  655.     return driver_list;

  656. }

  657. 

  658. #endif

  659. 

  660. #ifdef WIN32

  661. 

  662. JSList *

  663. jack_internals_load (JSList * internals) {

  664.     char * driver_dir;

  665.     char driver_dir_storage[512];

  666.     char dll_filename[512];

  667.     WIN32_FIND_DATA filedata;

  668.     HANDLE file;

  669.     const char * ptr = NULL;

  670.     JSList * driver_list = NULL;

  671.     jack_driver_desc_t * desc;

  672. 

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

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

  675.         GetCurrentDirectory(512, driver_dir_storage);

  676.         strcat(driver_dir_storage, "/");

  677.         strcat(driver_dir_storage, ADDON_DIR);

  678.         driver_dir = driver_dir_storage;

  679.     }

  680. 

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

  682. 

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

  684. 

  685.     if (file == INVALID_HANDLE_VALUE) {

  686.         jack_error("could not open driver directory %s", driver_dir);

  687.         return NULL;

  688.     }

  689. 

  690.     do {

  691. 

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

  693.         if (!ptr) {

  694.             continue;

  695.         }

  696.         ptr++;

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

  698.             continue;

  699.         }

  700. 

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

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

  703.              continue;

  704.         }

  705. 

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

  707.         if (desc) {

  708.             driver_list = jack_slist_append (driver_list, desc);

  709.         } else {

  710.             jack_error ("jack_get_descriptor returns null for \'%s\'", filedata.cFileName);

  711.         }

  712. 

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

  714. 

  715.     if (!driver_list) {

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

  717.         return NULL;

  718.     }

  719. 

  720.     return driver_list;

  721. }

  722. 

  723. #else

  724. 

  725. JSList *

  726. jack_internals_load (JSList * internals) {

  727.     struct dirent * dir_entry;

  728.     DIR * dir_stream;

  729.     const char * ptr;

  730.     int err;

  731.     JSList * driver_list = NULL;

  732.     jack_driver_desc_t * desc;

  733. 

  734.     const char* driver_dir;

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

  736.         driver_dir = ADDON_DIR;

  737.     }

  738. 

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

  740.     from the .so files in it */

  741.     dir_stream = opendir (driver_dir);

  742.     if (!dir_stream) {

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

  744.                     driver_dir, strerror (errno));

  745.         return NULL;

  746.     }

  747. 

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

  749. 

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

  751.         if (!ptr) {

  752.             continue;

  753.         }

  754.         ptr++;

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

  756.             continue;

  757.         }

  758. 

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

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

  761.              continue;

  762.         }

  763. 

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

  765.         if (desc) {

  766.             driver_list = jack_slist_append (driver_list, desc);

  767.         } else {

  768.             jack_error ("jack_get_descriptor returns null for \'%s\'", dir_entry->d_name);

  769.         }

  770.     }

  771. 

  772.     err = closedir (dir_stream);

  773.     if (err) {

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

  775.                     driver_dir, strerror (errno));

  776.     }

  777. 

  778.     if (!driver_list) {

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

  780.         return NULL;

  781.     }

  782. 

  783.     return driver_list;

  784. }

  785. 

  786. #endif

  787. 

  788. Jack::JackDriverClientInterface* JackDriverInfo::Open(jack_driver_desc_t* driver_desc,

  789.                                                     Jack::JackLockedEngine* engine,

  790.                                                     Jack::JackSynchro* synchro,

  791.                                                     const JSList* params)

  792. {

  793. #ifdef WIN32

  794.     int errstr;

  795. #else

  796.     const char * errstr;

  797. #endif

  798. 

  799.     fHandle = LoadDriverModule (driver_desc->file);

  800. 

  801.     if (fHandle == NULL) {

  802. #ifdef WIN32

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

  804.             jack_error ("can't load \"%s\": %ld", driver_desc->file, errstr);

  805. #else

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

  807.             jack_error ("can't load \"%s\": %s", driver_desc->file, errstr);

  808. #endif

  809. 

  810.         } else {

  811.             jack_error ("bizarre error loading driver shared object %s", driver_desc->file);

  812.         }

  813.         return NULL;

  814.     }

  815. 

  816.     fInitialize = (driverInitialize)GetDriverProc(fHandle, "driver_initialize");

  817. 

  818. #ifdef WIN32

  819.     if ((fInitialize == NULL) && (errstr = GetLastError ()) != 0) {

  820. #else

  821.     if ((fInitialize == NULL) && (errstr = dlerror ()) != 0) {

  822. #endif

  823.         jack_error("no initialize function in shared object %s\n", driver_desc->file);

  824.         return NULL;

  825.     }

  826. 

  827.     fBackend = fInitialize(engine, synchro, params);

  828.     return fBackend;

  829. }

  830. 

  831. JackDriverInfo::~JackDriverInfo()

  832. {

  833.     delete fBackend;

  834.     if (fHandle)

  835.         UnloadDriverModule(fHandle);

  836. }