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

959 lines
28KB
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 "JackDriverInfo.h"

  24. #include "JackConstants.h"

  25. #include "JackError.h"

  26. #include <getopt.h>

  27. #include <stdio.h>

  28. #include <errno.h>

  29. #include <string.h>

  30. 

  31. #ifndef WIN32

  32. #include <dirent.h>

  33. #endif

  34. 

  35. jack_driver_desc_t* jackctl_driver_get_desc(jackctl_driver_t * driver);

  36. 

  37. SERVER_EXPORT void jack_print_driver_options(jack_driver_desc_t* desc, FILE* file)

  38. {

  39.     unsigned long i;

  40.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  41. 

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

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

  44.             case JackDriverParamInt:

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

  46.                 break;

  47.             case JackDriverParamUInt:

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

  49.                 break;

  50.             case JackDriverParamChar:

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

  52.                 break;

  53.             case JackDriverParamString:

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

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

  56.                 } else {

  57.                     sprintf (arg_default, "none");

  58.                 }

  59.                 break;

  60.             case JackDriverParamBool:

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

  62.                 break;

  63.         }

  64. 

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

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

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

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

  69.                  arg_default);

  70.     }

  71. }

  72. 

  73. static void

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

  75. {

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

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

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

  79. }

  80. 

  81. SERVER_EXPORT void jack_free_driver_params(JSList * driver_params)

  82. {

  83.     JSList*node_ptr = driver_params;

  84.     JSList*next_node_ptr;

  85. 

  86.     while (node_ptr) {

  87.         next_node_ptr = node_ptr->next;

  88.         free(node_ptr->data);

  89.         free(node_ptr);

  90.         node_ptr = next_node_ptr;

  91.     }

  92. }

  93. 

  94. SERVER_EXPORT int

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

  96. {

  97.     struct option * long_options;

  98.     char* options, * options_ptr;

  99.     unsigned long i;

  100.     int opt;

  101.     unsigned int param_index;

  102.     JSList* params = NULL;

  103.     jack_driver_param_t * driver_param;

  104. 

  105.     if (argc <= 1) {

  106.         *param_ptr = NULL;

  107.         return 0;

  108.     }

  109. 

  110.     /* check for help */

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

  112.         if (argc > 2) {

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

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

  115.                     jack_print_driver_param_usage (desc, i, stdout);

  116.                     return 1;

  117.                 }

  118.             }

  119. 

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

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

  122.                      desc->name);

  123.         }

  124. 

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

  126.         jack_print_driver_options (desc, stdout);

  127.         return 1;

  128.     }

  129. 

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

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

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

  133. 

  134.     options_ptr = options;

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

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

  137.         options_ptr += 3;

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

  139.         long_options[i].flag = NULL;

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

  141.         long_options[i].has_arg = optional_argument;

  142.     }

  143. 

  144.     /* create the params */

  145.     optind = 0;

  146.     opterr = 0;

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

  148. 

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

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

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

  152.             } else {

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

  154.             }

  155. 

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

  157.             jack_print_driver_options (desc, stderr);

  158.             return 1;

  159.         }

  160. 

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

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

  163.                 break;

  164.             }

  165.         }

  166. 

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

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

  169. 

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

  171.                 strlen(argv[optind]) &&

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

  173.             optarg = argv[optind];

  174.         }

  175. 

  176.         if (optarg) {

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

  178.                 case JackDriverParamInt:

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

  180.                     break;

  181.                 case JackDriverParamUInt:

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

  183.                     break;

  184.                 case JackDriverParamChar:

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

  186.                     break;

  187.                 case JackDriverParamString:

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

  189.                     break;

  190.                 case JackDriverParamBool:

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

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

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

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

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

  196.                         driver_param->value.i = false;

  197.                     } else {

  198.                         driver_param->value.i = true;

  199.                     }

  200.                     break;

  201.             }

  202.         } else {

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

  204.                 driver_param->value.i = true;

  205.             } else {

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

  207.             }

  208.         }

  209. 

  210.         params = jack_slist_append (params, driver_param);

  211.     }

  212. 

  213.     free (options);

  214.     free (long_options);

  215. 

  216.     if (param_ptr) {

  217.         *param_ptr = params;

  218.     }

  219.     return 0;

  220. }

  221. 

  222. SERVER_EXPORT int

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

  224. {

  225.     struct option* long_options;

  226.     char* options, * options_ptr;

  227.     unsigned long i;

  228.     int opt;

  229.     JSList* node_ptr;

  230.     jackctl_parameter_t * param = NULL;

  231.     union jackctl_parameter_value value;

  232. 

  233.     if (argc <= 1) {

  234.         return 0;

  235.     }

  236. 

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

  238.     if (driver_params == NULL) {

  239.         return 1;

  240.     }

  241. 

  242.     jack_driver_desc_t* desc = jackctl_driver_get_desc(driver_ptr);

  243. 

  244.     /* check for help */

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

  246.         if (argc > 2) {

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

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

  249.                     jack_print_driver_param_usage (desc, i, stdout);

  250.                     return 1;

  251.                 }

  252.             }

  253. 

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

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

  256.                      desc->name);

  257.         }

  258. 

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

  260.         jack_print_driver_options (desc, stdout);

  261.         return 1;

  262.     }

  263. 

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

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

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

  267. 

  268.     options_ptr = options;

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

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

  271.         options_ptr += 3;

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

  273.         long_options[i].flag = NULL;

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

  275.         long_options[i].has_arg = optional_argument;

  276.     }

  277. 

  278.     /* create the params */

  279.     optind = 0;

  280.     opterr = 0;

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

  282. 

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

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

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

  286.             } else {

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

  288.             }

  289. 

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

  291.             jack_print_driver_options(desc, stderr);

  292.             return 1;

  293.         }

  294. 

  295.         node_ptr = (JSList *)driver_params;

  296.        	while (node_ptr) {

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

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

  299.                 break;

  300.             }

  301.             node_ptr = node_ptr->next;

  302.         }

  303. 

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

  305.             strlen(argv[optind]) &&

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

  307.             optarg = argv[optind];

  308.         }

  309. 

  310.         if (optarg) {

  311.             switch (jackctl_parameter_get_type(param)) {

  312.                 case JackDriverParamInt:

  313.                     value.i = atoi(optarg);

  314.                     jackctl_parameter_set_value(param, &value);

  315.                     break;

  316.                 case JackDriverParamUInt:

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

  318.                     jackctl_parameter_set_value(param, &value);

  319.                     break;

  320.                 case JackDriverParamChar:

  321.                     value.c = optarg[0];

  322.                     jackctl_parameter_set_value(param, &value);

  323.                     break;

  324.                 case JackDriverParamString:

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

  326.                     jackctl_parameter_set_value(param, &value);

  327.                     break;

  328.                 case JackDriverParamBool:

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

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

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

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

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

  334.                         value.i = false;

  335.                     } else {

  336.                         value.i = true;

  337.                     }

  338.                     jackctl_parameter_set_value(param, &value);

  339.                     break;

  340.             }

  341.         } else {

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

  343.                 value.i = true;

  344.             } else {

  345.                 value = jackctl_parameter_get_default_value(param);

  346.             }

  347.             jackctl_parameter_set_value(param, &value);

  348.         }

  349.     }

  350. 

  351.     free(options);

  352.     free(long_options);

  353.     return 0;

  354. }

  355. 

  356. jack_driver_desc_t*

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

  358. {

  359.     jack_driver_desc_t* desc = 0;

  360.     JSList* node;

  361. 

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

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

  364. 

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

  366.             desc = NULL;

  367.         } else {

  368.             break;

  369.         }

  370.     }

  371. 

  372.     return desc;

  373. }

  374. 

  375. static jack_driver_desc_t*

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

  377. {

  378.     jack_driver_desc_t* descriptor, * other_descriptor;

  379.     JackDriverDescFunction so_get_descriptor = NULL;

  380.     JSList* node;

  381.     void * dlhandle;

  382.     char* filename;

  383. #ifdef WIN32

  384.     int dlerr;

  385. #else

  386.     const char* dlerr;

  387. #endif

  388. 

  389.     int err;

  390.     const char* driver_dir;

  391. 

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

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

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

  395. #ifdef WIN32

  396.         char temp_driver_dir1[512];

  397.         char temp_driver_dir2[512];

  398.         if (3 < GetModuleFileName(NULL, temp_driver_dir1, 512)) {

  399.             char *p = strrchr(temp_driver_dir1, '\\');

  400.             if (p && (p != temp_driver_dir1))

  401.                 *p = 0;

  402.             else

  403.                 GetCurrentDirectory(512, temp_driver_dir1);

  404.         } else {

  405.             GetCurrentDirectory(512, temp_driver_dir1);

  406.         }

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

  408.         driver_dir = temp_driver_dir2;

  409. #else

  410.         driver_dir = ADDON_DIR;

  411. #endif

  412.     }

  413. 

  414.     int len = strlen(driver_dir) + 1 + strlen(sofile) + 1;

  415.     filename = (char*)malloc(len);

  416.     snprintf(filename, len, "%s/%s", driver_dir, sofile);

  417. 

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

  419. #ifdef WIN32

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

  421. #else

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

  423. #endif

  424. 

  425.         free(filename);

  426.         return NULL;

  427.     }

  428. 

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

  430. 

  431. #ifdef WIN32

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

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

  434. #else

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

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

  437. #endif

  438. 

  439.         UnloadDriverModule(dlhandle);

  440.         free(filename);

  441.         return NULL;

  442.     }

  443. 

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

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

  446.         UnloadDriverModule(dlhandle);

  447.         free(filename);

  448.         return NULL;

  449.     }

  450. 

  451. #ifdef WIN32

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

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

  454.     }

  455. #else

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

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

  458.     }

  459. #endif

  460. 

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

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

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

  464. 

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

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

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

  468.             /* FIXME: delete the descriptor */

  469.             free(filename);

  470.             return NULL;

  471.         }

  472.     }

  473. 

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

  475.     free(filename);

  476.     return descriptor;

  477. }

  478. 

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

  480. {

  481.     void * dlhandle;

  482.     bool res = false;

  483.     const char* driver_dir;

  484. 

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

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

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

  488. #ifdef WIN32

  489.         char temp_driver_dir1[512];

  490.         char temp_driver_dir2[512];

  491.         if (3 < GetModuleFileName(NULL, temp_driver_dir1, 512)) {

  492.             char *p = strrchr(temp_driver_dir1, '\\');

  493.             if (p && (p != temp_driver_dir1))

  494.                 *p = 0;

  495.             else

  496.                 GetCurrentDirectory(512, temp_driver_dir1);

  497.         } else {

  498.             GetCurrentDirectory(512, temp_driver_dir1);

  499.         }

  500.         snprintf(temp_driver_dir2, sizeof(temp_driver_dir2), "%s/%s", temp_driver_dir1, ADDON_DIR);

  501.         driver_dir = temp_driver_dir2;

  502. #else

  503.         driver_dir = ADDON_DIR;

  504. #endif

  505.     }

  506. 

  507.     int len = strlen(driver_dir) + 1 + strlen(sofile) + 1;

  508.     char* filename = (char*)malloc(len);

  509.     snprintf(filename, len, "%s/%s", driver_dir, sofile);

  510. 

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

  512. #ifdef WIN32

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

  514. #else

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

  516. #endif

  517.      } else {

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

  519.         UnloadDriverModule(dlhandle);

  520.     }

  521. 

  522.     free(filename);

  523.     return res;

  524. }

  525. 

  526. #ifdef WIN32

  527. 

  528. JSList *

  529. jack_drivers_load (JSList * drivers) {

  530.     char* driver_dir;

  531.     char driver_dir_storage[512];

  532.     char dll_filename[512];

  533.     WIN32_FIND_DATA filedata;

  534.     HANDLE file;

  535.     const char* ptr = NULL;

  536.     JSList* driver_list = NULL;

  537.     jack_driver_desc_t* desc = NULL;

  538. 

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

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

  541.         if (3 < GetModuleFileName(NULL, driver_dir_storage, 512)) {

  542.             char *p = strrchr(driver_dir_storage, '\\');

  543.             if (p && (p != driver_dir_storage))

  544.                 *p = 0;

  545.             else

  546.                 GetCurrentDirectory(512, driver_dir_storage);

  547.         } else {

  548.             GetCurrentDirectory(512, driver_dir_storage);

  549.         }

  550.         strcat(driver_dir_storage, "/");

  551.         strcat(driver_dir_storage, ADDON_DIR);

  552.         driver_dir = driver_dir_storage;

  553.     }

  554. 

  555.     snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  556. 

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

  558. 

  559.     if (file == INVALID_HANDLE_VALUE) {

  560.         jack_error("error invalid handle");

  561.         return NULL;

  562.     }

  563. 

  564.     do {

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

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

  567.             continue;

  568.         }

  569. 

  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.         /* check if dll is an internal client */

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

  581.              continue;

  582.         }

  583. 

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

  585.         if (desc) {

  586.             driver_list = jack_slist_append (driver_list, desc);

  587.         } else {

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

  589.         }

  590. 

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

  592. 

  593.     if (!driver_list) {

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

  595.         return NULL;

  596.     }

  597. 

  598.     return driver_list;

  599. }

  600. 

  601. #else

  602. 

  603. JSList *

  604. jack_drivers_load (JSList * drivers) {

  605.     struct dirent * dir_entry;

  606.     DIR * dir_stream;

  607.     const char* ptr;

  608.     int err;

  609.     JSList* driver_list = NULL;

  610.     jack_driver_desc_t* desc = NULL;

  611. 

  612.     const char* driver_dir;

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

  614.         driver_dir = ADDON_DIR;

  615.     }

  616. 

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

  618.     from the .so files in it */

  619.     dir_stream = opendir (driver_dir);

  620.     if (!dir_stream) {

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

  622.                     driver_dir, strerror (errno));

  623.         return NULL;

  624.     }

  625. 

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

  627. 

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

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

  630.             continue;

  631.         }

  632. 

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

  634.         if (!ptr) {

  635.             continue;

  636.         }

  637.         ptr++;

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

  639.             continue;

  640.         }

  641. 

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

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

  644.              continue;

  645.         }

  646. 

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

  648.         if (desc) {

  649.             driver_list = jack_slist_append (driver_list, desc);

  650.         } else {

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

  652.         }

  653.     }

  654. 

  655.     err = closedir (dir_stream);

  656.     if (err) {

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

  658.                     driver_dir, strerror (errno));

  659.     }

  660. 

  661.     if (!driver_list) {

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

  663.         return NULL;

  664.     }

  665. 

  666.     return driver_list;

  667. }

  668. 

  669. #endif

  670. 

  671. #ifdef WIN32

  672. 

  673. JSList *

  674. jack_internals_load (JSList * internals) {

  675.     char* driver_dir;

  676.     char driver_dir_storage[512];

  677.     char dll_filename[512];

  678.     WIN32_FIND_DATA filedata;

  679.     HANDLE file;

  680.     const char* ptr = NULL;

  681.     JSList* driver_list = NULL;

  682.     jack_driver_desc_t* desc;

  683. 

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

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

  686.         if (3 < GetModuleFileName(NULL, driver_dir_storage, 512)) {

  687.             char *p = strrchr(driver_dir_storage, '\\');

  688.             if (p && (p != driver_dir_storage))

  689.                 *p = 0;

  690.             else

  691.                 GetCurrentDirectory(512, driver_dir_storage);

  692.         } else {

  693.             GetCurrentDirectory(512, driver_dir_storage);

  694.         }

  695.         strcat(driver_dir_storage, "/");

  696.         strcat(driver_dir_storage, ADDON_DIR);

  697.         driver_dir = driver_dir_storage;

  698.     }

  699. 

  700.     snprintf(dll_filename, sizeof(dll_filename), "%s/*.dll", driver_dir);

  701. 

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

  703. 

  704.     if (file == INVALID_HANDLE_VALUE) {

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

  706.         return NULL;

  707.     }

  708. 

  709.     do {

  710. 

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

  712.         if (!ptr) {

  713.             continue;

  714.         }

  715.         ptr++;

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

  717.             continue;

  718.         }

  719. 

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

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

  722.              continue;

  723.         }

  724. 

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

  726.         if (desc) {

  727.             driver_list = jack_slist_append (driver_list, desc);

  728.         } else {

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

  730.         }

  731. 

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

  733. 

  734.     if (!driver_list) {

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

  736.         return NULL;

  737.     }

  738. 

  739.     return driver_list;

  740. }

  741. 

  742. #else

  743. 

  744. JSList *

  745. jack_internals_load (JSList * internals) {

  746.     struct dirent * dir_entry;

  747.     DIR * dir_stream;

  748.     const char* ptr;

  749.     int err;

  750.     JSList* driver_list = NULL;

  751.     jack_driver_desc_t* desc;

  752. 

  753.     const char* driver_dir;

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

  755.         driver_dir = ADDON_DIR;

  756.     }

  757. 

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

  759.     from the .so files in it */

  760.     dir_stream = opendir (driver_dir);

  761.     if (!dir_stream) {

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

  763.                     driver_dir, strerror (errno));

  764.         return NULL;

  765.     }

  766. 

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

  768. 

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

  770.         if (!ptr) {

  771.             continue;

  772.         }

  773.         ptr++;

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

  775.             continue;

  776.         }

  777. 

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

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

  780.              continue;

  781.         }

  782. 

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

  784.         if (desc) {

  785.             driver_list = jack_slist_append (driver_list, desc);

  786.         } else {

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

  788.         }

  789.     }

  790. 

  791.     err = closedir (dir_stream);

  792.     if (err) {

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

  794.                     driver_dir, strerror (errno));

  795.     }

  796. 

  797.     if (!driver_list) {

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

  799.         return NULL;

  800.     }

  801. 

  802.     return driver_list;

  803. }

  804. 

  805. #endif

  806. 

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

  808.                                                     Jack::JackLockedEngine* engine,

  809.                                                     Jack::JackSynchro* synchro,

  810.                                                     const JSList* params)

  811. {

  812. #ifdef WIN32

  813.     int errstr;

  814. #else

  815.     const char* errstr;

  816. #endif

  817. 

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

  819. 

  820.     if (fHandle == NULL) {

  821. #ifdef WIN32

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

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

  824. #else

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

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

  827. #endif

  828. 

  829.         } else {

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

  831.         }

  832.         return NULL;

  833.     }

  834. 

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

  836. 

  837. #ifdef WIN32

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

  839. #else

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

  841. #endif

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

  843.         return NULL;

  844.     }

  845. 

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

  847.     return fBackend;

  848. }

  849. 

  850. JackDriverInfo::~JackDriverInfo()

  851. {

  852.     delete fBackend;

  853.     if (fHandle)

  854.         UnloadDriverModule(fHandle);

  855. }

  856. 

  857. SERVER_EXPORT

  858. jack_driver_desc_t*

  859. jack_driver_descriptor_construct(

  860.     const char * name,

  861.     jack_driver_type_t type,

  862.     const char * description,

  863.     jack_driver_desc_filler_t * filler_ptr)

  864. {

  865.     size_t name_len;

  866.     size_t description_len;

  867.     jack_driver_desc_t* desc_ptr;

  868. 

  869.     name_len = strlen(name);

  870.     description_len = strlen(description);

  871. 

  872.     if (name_len > sizeof(desc_ptr->name) - 1 ||

  873.         description_len > sizeof(desc_ptr->desc) - 1) {

  874.         assert(false);

  875.         return 0;

  876.     }

  877. 

  878.     desc_ptr = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));

  879.     if (desc_ptr == NULL) {

  880.         jack_error("calloc() failed to allocate memory for driver descriptor struct");

  881.         return 0;

  882.     }

  883. 

  884.     memcpy(desc_ptr->name, name, name_len + 1);

  885.     memcpy(desc_ptr->desc, description, description_len + 1);

  886. 

  887.     desc_ptr->nparams = 0;

  888.     desc_ptr->type = type;

  889. 

  890.     if (filler_ptr != NULL) {

  891.         filler_ptr->size = 0;

  892.     }

  893. 

  894.     return desc_ptr;

  895. }

  896. 

  897. SERVER_EXPORT

  898. int

  899. jack_driver_descriptor_add_parameter(

  900.     jack_driver_desc_t* desc_ptr,

  901.     jack_driver_desc_filler_t * filler_ptr,

  902.     const char* name,

  903.     char character,

  904.     jack_driver_param_type_t type,

  905.     const jack_driver_param_value_t * value_ptr,

  906.     jack_driver_param_constraint_desc_t * constraint,

  907.     const char* short_desc,

  908.     const char* long_desc)

  909. {

  910.     size_t name_len;

  911.     size_t short_desc_len;

  912.     size_t long_desc_len;

  913.     jack_driver_param_desc_t * param_ptr;

  914.     size_t newsize;

  915. 

  916.     name_len = strlen(name);

  917.     short_desc_len = strlen(short_desc);

  918. 

  919.     if (long_desc != NULL) {

  920.         long_desc_len = strlen(long_desc);

  921.     } else {

  922.         long_desc = short_desc;

  923.         long_desc_len = short_desc_len;

  924.     }

  925. 

  926.     if (name_len > sizeof(param_ptr->name) - 1 ||

  927.         short_desc_len > sizeof(param_ptr->short_desc) - 1 ||

  928.         long_desc_len > sizeof(param_ptr->long_desc) - 1) {

  929.         assert(false);

  930.         return 0;

  931.     }

  932. 

  933.     if (desc_ptr->nparams == filler_ptr->size) {

  934.         newsize = filler_ptr->size + 20; // most drivers have less than 20 parameters

  935.         param_ptr = (jack_driver_param_desc_t*)realloc (desc_ptr->params, newsize * sizeof (jack_driver_param_desc_t));

  936.         if (param_ptr == NULL) {

  937.             jack_error("realloc() failed for parameter array of %zu elements", newsize);

  938.             return false;

  939.         }

  940.         filler_ptr->size = newsize;

  941.         desc_ptr->params = param_ptr;

  942.     }

  943. 

  944.     assert(desc_ptr->nparams < filler_ptr->size);

  945.     param_ptr = desc_ptr->params + desc_ptr->nparams;

  946. 

  947.     memcpy(param_ptr->name, name, name_len + 1);

  948.     param_ptr->character = character;

  949.     param_ptr->type = type;

  950.     param_ptr->value = *value_ptr;

  951.     param_ptr->constraint = constraint;

  952.     memcpy(param_ptr->short_desc, short_desc, short_desc_len + 1);

  953.     memcpy(param_ptr->long_desc, long_desc, long_desc_len + 1);

  954. 

  955.     desc_ptr->nparams++;

  956. 

  957.     return true;

  958. }