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

956 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 "JackConstants.h"

  24. #include "JackError.h"

  25. #include <getopt.h>

  26. #include <stdio.h>

  27. #include <errno.h>

  28. #include <string.h>

  29. 

  30. #ifndef WIN32

  31. #include <dirent.h>

  32. #endif

  33. 

  34. jack_driver_desc_t* jackctl_driver_get_desc(jackctl_driver_t * driver);

  35. 

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

  37. {

  38.     unsigned long i;

  39.     char arg_default[JACK_DRIVER_PARAM_STRING_MAX + 1];

  40. 

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

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

  43.             case JackDriverParamInt:

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

  45.                 break;

  46.             case JackDriverParamUInt:

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

  48.                 break;

  49.             case JackDriverParamChar:

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

  51.                 break;

  52.             case JackDriverParamString:

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

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

  55.                 } else {

  56.                     sprintf (arg_default, "none");

  57.                 }

  58.                 break;

  59.             case JackDriverParamBool:

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

  61.                 break;

  62.         }

  63. 

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

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

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

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

  68.                  arg_default);

  69.     }

  70. }

  71. 

  72. static void

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

  74. {

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

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

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

  78. }

  79. 

  80. SERVER_EXPORT void jack_free_driver_params(JSList * driver_params)

  81. {

  82.     JSList*node_ptr = driver_params;

  83.     JSList*next_node_ptr;

  84. 

  85.     while (node_ptr) {

  86.         next_node_ptr = node_ptr->next;

  87.         free(node_ptr->data);

  88.         free(node_ptr);

  89.         node_ptr = next_node_ptr;

  90.     }

  91. }

  92. 

  93. SERVER_EXPORT int

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

  95. {

  96.     struct option * long_options;

  97.     char* options, * options_ptr;

  98.     unsigned long i;

  99.     int opt;

  100.     unsigned int param_index;

  101.     JSList* params = NULL;

  102.     jack_driver_param_t * driver_param;

  103. 

  104.     if (argc <= 1) {

  105.         *param_ptr = NULL;

  106.         return 0;

  107.     }

  108. 

  109.     /* check for help */

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

  111.         if (argc > 2) {

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

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

  114.                     jack_print_driver_param_usage (desc, i, stdout);

  115.                     return 1;

  116.                 }

  117.             }

  118. 

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

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

  121.                      desc->name);

  122.         }

  123. 

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

  125.         jack_print_driver_options (desc, stdout);

  126.         return 1;

  127.     }

  128. 

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

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

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

  132. 

  133.     options_ptr = options;

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

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

  136.         options_ptr += 3;

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

  138.         long_options[i].flag = NULL;

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

  140.         long_options[i].has_arg = optional_argument;

  141.     }

  142. 

  143.     /* create the params */

  144.     optind = 0;

  145.     opterr = 0;

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

  147. 

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

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

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

  151.             } else {

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

  153.             }

  154. 

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

  156.             jack_print_driver_options (desc, stderr);

  157.             return 1;

  158.         }

  159. 

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

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

  162.                 break;

  163.             }

  164.         }

  165. 

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

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

  168. 

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

  170.                 strlen(argv[optind]) &&

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

  172.             optarg = argv[optind];

  173.         }

  174. 

  175.         if (optarg) {

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

  177.                 case JackDriverParamInt:

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

  179.                     break;

  180.                 case JackDriverParamUInt:

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

  182.                     break;

  183.                 case JackDriverParamChar:

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

  185.                     break;

  186.                 case JackDriverParamString:

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

  188.                     break;

  189.                 case JackDriverParamBool:

  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.                         driver_param->value.i = false;

  196.                     } else {

  197.                         driver_param->value.i = true;

  198.                     }

  199.                     break;

  200.             }

  201.         } else {

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

  203.                 driver_param->value.i = true;

  204.             } else {

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

  206.             }

  207.         }

  208. 

  209.         params = jack_slist_append (params, driver_param);

  210.     }

  211. 

  212.     free (options);

  213.     free (long_options);

  214. 

  215.     if (param_ptr) {

  216.         *param_ptr = params;

  217.     }

  218.     return 0;

  219. }

  220. 

  221. SERVER_EXPORT int

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

  223. {

  224.     struct option* long_options;

  225.     char* options, * options_ptr;

  226.     unsigned long i;

  227.     int opt;

  228.     JSList* node_ptr;

  229.     jackctl_parameter_t * param = NULL;

  230.     union jackctl_parameter_value value;

  231. 

  232.     if (argc <= 1) {

  233.         return 0;

  234.     }

  235. 

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

  237.     if (driver_params == NULL) {

  238.         return 1;

  239.     }

  240. 

  241.     jack_driver_desc_t* desc = jackctl_driver_get_desc(driver_ptr);

  242. 

  243.     /* check for help */

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

  245.         if (argc > 2) {

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

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

  248.                     jack_print_driver_param_usage (desc, i, stdout);

  249.                     return 1;

  250.                 }

  251.             }

  252. 

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

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

  255.                      desc->name);

  256.         }

  257. 

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

  259.         jack_print_driver_options (desc, stdout);

  260.         return 1;

  261.     }

  262. 

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

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

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

  266. 

  267.     options_ptr = options;

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

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

  270.         options_ptr += 3;

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

  272.         long_options[i].flag = NULL;

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

  274.         long_options[i].has_arg = optional_argument;

  275.     }

  276. 

  277.     /* create the params */

  278.     optind = 0;

  279.     opterr = 0;

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

  281. 

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

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

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

  285.             } else {

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

  287.             }

  288. 

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

  290.             jack_print_driver_options(desc, stderr);

  291.             return 1;

  292.         }

  293. 

  294.         node_ptr = (JSList *)driver_params;

  295.        	while (node_ptr) {

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

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

  298.                 break;

  299.             }

  300.             node_ptr = node_ptr->next;

  301.         }

  302. 

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

  304.             strlen(argv[optind]) &&

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

  306.             optarg = argv[optind];

  307.         }

  308. 

  309.         if (optarg) {

  310.             switch (jackctl_parameter_get_type(param)) {

  311.                 case JackDriverParamInt:

  312.                     value.i = atoi(optarg);

  313.                     jackctl_parameter_set_value(param, &value);

  314.                     break;

  315.                 case JackDriverParamUInt:

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

  317.                     jackctl_parameter_set_value(param, &value);

  318.                     break;

  319.                 case JackDriverParamChar:

  320.                     value.c = optarg[0];

  321.                     jackctl_parameter_set_value(param, &value);

  322.                     break;

  323.                 case JackDriverParamString:

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

  325.                     jackctl_parameter_set_value(param, &value);

  326.                     break;

  327.                 case JackDriverParamBool:

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

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

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

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

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

  333.                         value.i = false;

  334.                     } else {

  335.                         value.i = true;

  336.                     }

  337.                     jackctl_parameter_set_value(param, &value);

  338.                     break;

  339.             }

  340.         } else {

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

  342.                 value.i = true;

  343.             } else {

  344.                 value = jackctl_parameter_get_default_value(param);

  345.             }

  346.             jackctl_parameter_set_value(param, &value);

  347.         }

  348.     }

  349. 

  350.     free(options);

  351.     free(long_options);

  352.     return 0;

  353. }

  354. 

  355. jack_driver_desc_t*

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

  357. {

  358.     jack_driver_desc_t* desc = 0;

  359.     JSList* node;

  360. 

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

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

  363. 

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

  365.             desc = NULL;

  366.         } else {

  367.             break;

  368.         }

  369.     }

  370. 

  371.     return desc;

  372. }

  373. 

  374. static jack_driver_desc_t*

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

  376. {

  377.     jack_driver_desc_t* descriptor, * other_descriptor;

  378.     JackDriverDescFunction so_get_descriptor = NULL;

  379.     JSList* node;

  380.     void * dlhandle;

  381.     char* filename;

  382. #ifdef WIN32

  383.     int dlerr;

  384. #else

  385.     const char* dlerr;

  386. #endif

  387. 

  388.     int err;

  389.     const char* driver_dir;

  390. 

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

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

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

  394. #ifdef WIN32

  395.         char temp_driver_dir1[512];

  396.         char temp_driver_dir2[512];

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

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

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

  400.                 *p = 0;

  401.             else

  402.                 GetCurrentDirectory(512, temp_driver_dir1);

  403.         } else {

  404.             GetCurrentDirectory(512, temp_driver_dir1);

  405.         }

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

  407.         driver_dir = temp_driver_dir2;

  408. #else

  409.         driver_dir = ADDON_DIR;

  410. #endif

  411.     }

  412. 

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

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

  415. 

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

  417. #ifdef WIN32

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

  419. #else

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

  421. #endif

  422. 

  423.         free(filename);

  424.         return NULL;

  425.     }

  426. 

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

  428. 

  429. #ifdef WIN32

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

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

  432. #else

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

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

  435. #endif

  436. 

  437.         UnloadDriverModule(dlhandle);

  438.         free(filename);

  439.         return NULL;

  440.     }

  441. 

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

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

  444.         UnloadDriverModule(dlhandle);

  445.         free(filename);

  446.         return NULL;

  447.     }

  448. 

  449. #ifdef WIN32

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

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

  452.     }

  453. #else

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

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

  456.     }

  457. #endif

  458. 

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

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

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

  462. 

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

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

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

  466.             /* FIXME: delete the descriptor */

  467.             free(filename);

  468.             return NULL;

  469.         }

  470.     }

  471. 

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

  473.     free(filename);

  474.     return descriptor;

  475. }

  476. 

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

  478. {

  479.     void * dlhandle;

  480.     bool res = false;

  481.     const char* driver_dir;

  482. 

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

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

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

  486. #ifdef WIN32

  487.         char temp_driver_dir1[512];

  488.         char temp_driver_dir2[512];

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

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

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

  492.                 *p = 0;

  493.             else

  494.                 GetCurrentDirectory(512, temp_driver_dir1);

  495.         } else {

  496.             GetCurrentDirectory(512, temp_driver_dir1);

  497.         }

  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.         if (3 < GetModuleFileName(NULL, driver_dir_storage, 512)) {

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

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

  541.                 *p = 0;

  542.             else

  543.                 GetCurrentDirectory(512, driver_dir_storage);

  544.         } else {

  545.             GetCurrentDirectory(512, driver_dir_storage);

  546.         }

  547.         strcat(driver_dir_storage, "/");

  548.         strcat(driver_dir_storage, ADDON_DIR);

  549.         driver_dir = driver_dir_storage;

  550.     }

  551. 

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

  553. 

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

  555. 

  556.     if (file == INVALID_HANDLE_VALUE) {

  557.         jack_error("error invalid handle");

  558.         return NULL;

  559.     }

  560. 

  561.     do {

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

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

  564.             continue;

  565.         }

  566. 

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

  568.         if (!ptr) {

  569.             continue;

  570.         }

  571.         ptr++;

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

  573.             continue;

  574.         }

  575. 

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

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

  578.              continue;

  579.         }

  580. 

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

  582.         if (desc) {

  583.             driver_list = jack_slist_append (driver_list, desc);

  584.         } else {

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

  586.         }

  587. 

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

  589. 

  590.     if (!driver_list) {

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

  592.         return NULL;

  593.     }

  594. 

  595.     return driver_list;

  596. }

  597. 

  598. #else

  599. 

  600. JSList *

  601. jack_drivers_load (JSList * drivers) {

  602.     struct dirent * dir_entry;

  603.     DIR * dir_stream;

  604.     const char* ptr;

  605.     int err;

  606.     JSList* driver_list = NULL;

  607.     jack_driver_desc_t* desc = NULL;

  608. 

  609.     const char* driver_dir;

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

  611.         driver_dir = ADDON_DIR;

  612.     }

  613. 

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

  615.     from the .so files in it */

  616.     dir_stream = opendir (driver_dir);

  617.     if (!dir_stream) {

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

  619.                     driver_dir, strerror (errno));

  620.         return NULL;

  621.     }

  622. 

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

  624. 

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

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

  627.             continue;

  628.         }

  629. 

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

  631.         if (!ptr) {

  632.             continue;

  633.         }

  634.         ptr++;

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

  636.             continue;

  637.         }

  638. 

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

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

  641.              continue;

  642.         }

  643. 

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

  645.         if (desc) {

  646.             driver_list = jack_slist_append (driver_list, desc);

  647.         } else {

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

  649.         }

  650.     }

  651. 

  652.     err = closedir (dir_stream);

  653.     if (err) {

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

  655.                     driver_dir, strerror (errno));

  656.     }

  657. 

  658.     if (!driver_list) {

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

  660.         return NULL;

  661.     }

  662. 

  663.     return driver_list;

  664. }

  665. 

  666. #endif

  667. 

  668. #ifdef WIN32

  669. 

  670. JSList *

  671. jack_internals_load (JSList * internals) {

  672.     char* driver_dir;

  673.     char driver_dir_storage[512];

  674.     char dll_filename[512];

  675.     WIN32_FIND_DATA filedata;

  676.     HANDLE file;

  677.     const char* ptr = NULL;

  678.     JSList* driver_list = NULL;

  679.     jack_driver_desc_t* desc;

  680. 

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

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

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

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

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

  686.                 *p = 0;

  687.             else

  688.                 GetCurrentDirectory(512, driver_dir_storage);

  689.         } else {

  690.             GetCurrentDirectory(512, driver_dir_storage);

  691.         }

  692.         strcat(driver_dir_storage, "/");

  693.         strcat(driver_dir_storage, ADDON_DIR);

  694.         driver_dir = driver_dir_storage;

  695.     }

  696. 

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

  698. 

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

  700. 

  701.     if (file == INVALID_HANDLE_VALUE) {

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

  703.         return NULL;

  704.     }

  705. 

  706.     do {

  707. 

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

  709.         if (!ptr) {

  710.             continue;

  711.         }

  712.         ptr++;

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

  714.             continue;

  715.         }

  716. 

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

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

  719.              continue;

  720.         }

  721. 

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

  723.         if (desc) {

  724.             driver_list = jack_slist_append (driver_list, desc);

  725.         } else {

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

  727.         }

  728. 

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

  730. 

  731.     if (!driver_list) {

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

  733.         return NULL;

  734.     }

  735. 

  736.     return driver_list;

  737. }

  738. 

  739. #else

  740. 

  741. JSList *

  742. jack_internals_load (JSList * internals) {

  743.     struct dirent * dir_entry;

  744.     DIR * dir_stream;

  745.     const char* ptr;

  746.     int err;

  747.     JSList* driver_list = NULL;

  748.     jack_driver_desc_t* desc;

  749. 

  750.     const char* driver_dir;

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

  752.         driver_dir = ADDON_DIR;

  753.     }

  754. 

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

  756.     from the .so files in it */

  757.     dir_stream = opendir (driver_dir);

  758.     if (!dir_stream) {

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

  760.                     driver_dir, strerror (errno));

  761.         return NULL;

  762.     }

  763. 

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

  765. 

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

  767.         if (!ptr) {

  768.             continue;

  769.         }

  770.         ptr++;

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

  772.             continue;

  773.         }

  774. 

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

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

  777.              continue;

  778.         }

  779. 

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

  781.         if (desc) {

  782.             driver_list = jack_slist_append (driver_list, desc);

  783.         } else {

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

  785.         }

  786.     }

  787. 

  788.     err = closedir (dir_stream);

  789.     if (err) {

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

  791.                     driver_dir, strerror (errno));

  792.     }

  793. 

  794.     if (!driver_list) {

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

  796.         return NULL;

  797.     }

  798. 

  799.     return driver_list;

  800. }

  801. 

  802. #endif

  803. 

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

  805.                                                     Jack::JackLockedEngine* engine,

  806.                                                     Jack::JackSynchro* synchro,

  807.                                                     const JSList* params)

  808. {

  809. #ifdef WIN32

  810.     int errstr;

  811. #else

  812.     const char* errstr;

  813. #endif

  814. 

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

  816. 

  817.     if (fHandle == NULL) {

  818. #ifdef WIN32

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

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

  821. #else

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

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

  824. #endif

  825. 

  826.         } else {

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

  828.         }

  829.         return NULL;

  830.     }

  831. 

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

  833. 

  834. #ifdef WIN32

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

  836. #else

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

  838. #endif

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

  840.         return NULL;

  841.     }

  842. 

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

  844.     return fBackend;

  845. }

  846. 

  847. JackDriverInfo::~JackDriverInfo()

  848. {

  849.     delete fBackend;

  850.     if (fHandle)

  851.         UnloadDriverModule(fHandle);

  852. }

  853. 

  854. SERVER_EXPORT

  855. jack_driver_desc_t*

  856. jack_driver_descriptor_construct(

  857.     const char * name,

  858.     jack_driver_type_t type,

  859.     const char * description,

  860.     jack_driver_desc_filler_t * filler_ptr)

  861. {

  862.     size_t name_len;

  863.     size_t description_len;

  864.     jack_driver_desc_t* desc_ptr;

  865. 

  866.     name_len = strlen(name);

  867.     description_len = strlen(description);

  868. 

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

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

  871.         assert(false);

  872.         return 0;

  873.     }

  874. 

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

  876.     if (desc_ptr == NULL) {

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

  878.         return 0;

  879.     }

  880. 

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

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

  883. 

  884.     desc_ptr->nparams = 0;

  885.     desc_ptr->type = type;

  886. 

  887.     if (filler_ptr != NULL) {

  888.         filler_ptr->size = 0;

  889.     }

  890. 

  891.     return desc_ptr;

  892. }

  893. 

  894. SERVER_EXPORT

  895. int

  896. jack_driver_descriptor_add_parameter(

  897.     jack_driver_desc_t* desc_ptr,

  898.     jack_driver_desc_filler_t * filler_ptr,

  899.     const char* name,

  900.     char character,

  901.     jack_driver_param_type_t type,

  902.     const jack_driver_param_value_t * value_ptr,

  903.     jack_driver_param_constraint_desc_t * constraint,

  904.     const char* short_desc,

  905.     const char* long_desc)

  906. {

  907.     size_t name_len;

  908.     size_t short_desc_len;

  909.     size_t long_desc_len;

  910.     jack_driver_param_desc_t * param_ptr;

  911.     size_t newsize;

  912. 

  913.     name_len = strlen(name);

  914.     short_desc_len = strlen(short_desc);

  915. 

  916.     if (long_desc != NULL) {

  917.         long_desc_len = strlen(long_desc);

  918.     } else {

  919.         long_desc = short_desc;

  920.         long_desc_len = short_desc_len;

  921.     }

  922. 

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

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

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

  926.         assert(false);

  927.         return 0;

  928.     }

  929. 

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

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

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

  933.         if (param_ptr == NULL) {

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

  935.             return false;

  936.         }

  937.         filler_ptr->size = newsize;

  938.         desc_ptr->params = param_ptr;

  939.     }

  940. 

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

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

  943. 

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

  945.     param_ptr->character = character;

  946.     param_ptr->type = type;

  947.     param_ptr->value = *value_ptr;

  948.     param_ptr->constraint = constraint;

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

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

  951. 

  952.     desc_ptr->nparams++;

  953. 

  954.     return true;

  955. }