common/JackControlAPI.cpp

   1 // u/* -*- Mode: C++ ; c-basic-offset: 4 -*- */
   2 /*
   3   JACK control API implementation
   4
   5   Copyright (C) 2008 Nedko Arnaudov
   6   Copyright (C) 2008 Grame
   7
   8   This program is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation; version 2 of the License.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 */
  22
  23 #ifndef WIN32
  24 #include <stdint.h>
  25 #include <dirent.h>
  26 #include <pthread.h>
  27 #endif
  28
  29 #include "types.h"
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <assert.h>
  34 #include <signal.h>
  35
  36 #include "jslist.h"
  37 #include "driver_interface.h"
  38 #include "JackError.h"
  39 #include "JackServer.h"
  40 #include "shm.h"
  41 #include "JackTools.h"
  42 #include "JackControlAPI.h"
  43 #include "JackLockedEngine.h"
  44 #include "JackConstants.h"
  45 #include "JackDriverLoader.h"
  46 #include "JackServerGlobals.h"
  47
  48 using namespace Jack;
  49
  50 struct jackctl_server
  51 {
  52     JSList * drivers;
  53     JSList * internals;
  54     JSList * parameters;
  55
  56     class JackServer * engine;
  57
  58     /* string, server name */
  59     union jackctl_parameter_value name;
  60     union jackctl_parameter_value default_name;
  61
  62     /* bool, whether to be "realtime" */
  63     union jackctl_parameter_value realtime;
  64     union jackctl_parameter_value default_realtime;
  65
  66     /* int32_t */
  67     union jackctl_parameter_value realtime_priority;
  68     union jackctl_parameter_value default_realtime_priority;
  69
  70     /* bool, whether to exit once all clients have closed their connections */
  71     union jackctl_parameter_value temporary;
  72     union jackctl_parameter_value default_temporary;
  73
  74     /* bool, whether to be verbose */
  75     union jackctl_parameter_value verbose;
  76     union jackctl_parameter_value default_verbose;
  77
  78     /* int32_t, msecs; if zero, use period size. */
  79     union jackctl_parameter_value client_timeout;
  80     union jackctl_parameter_value default_client_timeout;
  81
  82     /* uint32_t, clock source type */
  83     union jackctl_parameter_value clock_source;
  84     union jackctl_parameter_value default_clock_source;
  85
  86     /* uint32_t, max port number */
  87     union jackctl_parameter_value port_max;
  88     union jackctl_parameter_value default_port_max;
  89
  90     /* bool */
  91     union jackctl_parameter_value replace_registry;
  92     union jackctl_parameter_value default_replace_registry;
  93
  94     /* bool, synchronous or asynchronous engine mode */
  95     union jackctl_parameter_value sync;
  96     union jackctl_parameter_value default_sync;
  97 };
  98
  99 struct jackctl_driver
 100 {
 101     jack_driver_desc_t * desc_ptr;
 102     JSList * parameters;
 103     JSList * infos;
 104 };
 105
 106 struct jackctl_internal
 107 {
 108     jack_driver_desc_t * desc_ptr;
 109     JSList * parameters;
 110     int refnum;
 111 };
 112
 113 struct jackctl_parameter
 114 {
 115     const char * name;
 116     const char * short_description;
 117     const char * long_description;
 118     jackctl_param_type_t type;
 119     bool is_set;
 120     union jackctl_parameter_value * value_ptr;
 121     union jackctl_parameter_value * default_value_ptr;
 122
 123     union jackctl_parameter_value value;
 124     union jackctl_parameter_value default_value;
 125     struct jackctl_driver * driver_ptr;
 126     char id;
 127     jack_driver_param_constraint_desc_t * constraint_ptr;
 128 };
 129
 130 static
 131 struct jackctl_parameter *
 132 jackctl_add_parameter(
 133     JSList ** parameters_list_ptr_ptr,
 134     const char * name,
 135     const char * short_description,
 136     const char * long_description,
 137     jackctl_param_type_t type,
 138     union jackctl_parameter_value * value_ptr,
 139     union jackctl_parameter_value * default_value_ptr,
 140     union jackctl_parameter_value value,
 141     jack_driver_param_constraint_desc_t * constraint_ptr = NULL)
 142 {
 143     struct jackctl_parameter * parameter_ptr;
 144
 145     parameter_ptr = (struct jackctl_parameter *)malloc(sizeof(struct jackctl_parameter));
 146     if (parameter_ptr == NULL)
 147     {
 148         jack_error("Cannot allocate memory for jackctl_parameter structure.");
 149         goto fail;
 150     }
 151
 152     parameter_ptr->name = name;
 153     parameter_ptr->short_description = short_description;
 154     parameter_ptr->long_description = long_description;
 155     parameter_ptr->type = type;
 156     parameter_ptr->is_set = false;
 157
 158     if (value_ptr == NULL)
 159     {
 160         value_ptr = &parameter_ptr->value;
 161     }
 162
 163     if (default_value_ptr == NULL)
 164     {
 165         default_value_ptr = &parameter_ptr->default_value;
 166     }
 167
 168     parameter_ptr->value_ptr = value_ptr;
 169     parameter_ptr->default_value_ptr = default_value_ptr;
 170
 171     *value_ptr = *default_value_ptr = value;
 172
 173     parameter_ptr->driver_ptr = NULL;
 174     parameter_ptr->id = 0;
 175     parameter_ptr->constraint_ptr = constraint_ptr;
 176
 177     *parameters_list_ptr_ptr = jack_slist_append(*parameters_list_ptr_ptr, parameter_ptr);
 178
 179     return parameter_ptr;
 180
 181 fail:
 182     return NULL;
 183 }
 184
 185 static
 186 void
 187 jackctl_free_driver_parameters(
 188     struct jackctl_driver * driver_ptr)
 189 {
 190     JSList * next_node_ptr;
 191
 192     while (driver_ptr->parameters)
 193     {
 194         next_node_ptr = driver_ptr->parameters->next;
 195         free(driver_ptr->parameters->data);
 196         free(driver_ptr->parameters);
 197         driver_ptr->parameters = next_node_ptr;
 198     }
 199 }
 200
 201 static
 202 bool
 203 jackctl_add_driver_parameters(
 204     struct jackctl_driver * driver_ptr)
 205 {
 206     unsigned int i;
 207
 208     union jackctl_parameter_value jackctl_value;
 209     jackctl_param_type_t jackctl_type;
 210     struct jackctl_parameter * parameter_ptr;
 211     jack_driver_param_desc_t * descriptor_ptr;
 212
 213     for (i = 0 ; i < driver_ptr->desc_ptr->nparams ; i++)
 214     {
 215         descriptor_ptr = driver_ptr->desc_ptr->params + i;
 216
 217         switch (descriptor_ptr->type)
 218         {
 219         case JackDriverParamInt:
 220             jackctl_type = JackParamInt;
 221             jackctl_value.i = descriptor_ptr->value.i;
 222             break;
 223         case JackDriverParamUInt:
 224             jackctl_type = JackParamUInt;
 225             jackctl_value.ui = descriptor_ptr->value.ui;
 226             break;
 227         case JackDriverParamChar:
 228             jackctl_type = JackParamChar;
 229             jackctl_value.c = descriptor_ptr->value.c;
 230             break;
 231         case JackDriverParamString:
 232             jackctl_type = JackParamString;
 233             strcpy(jackctl_value.str, descriptor_ptr->value.str);
 234             break;
 235         case JackDriverParamBool:
 236             jackctl_type = JackParamBool;
 237             jackctl_value.b = descriptor_ptr->value.i;
 238             break;
 239         default:
 240             jack_error("Unknown driver parameter type %i", (int)descriptor_ptr->type);
 241             assert(0);
 242             goto fail;
 243         }
 244
 245         parameter_ptr = jackctl_add_parameter(
 246             &driver_ptr->parameters,
 247             descriptor_ptr->name,
 248             descriptor_ptr->short_desc,
 249             descriptor_ptr->long_desc,
 250             jackctl_type,
 251             NULL,
 252             NULL,
 253             jackctl_value,
 254             descriptor_ptr->constraint);
 255
 256         if (parameter_ptr == NULL)
 257         {
 258             goto fail;
 259         }
 260
 261         parameter_ptr->driver_ptr = driver_ptr;
 262         parameter_ptr->id = descriptor_ptr->character;
 263     }
 264
 265     return true;
 266
 267 fail:
 268     jackctl_free_driver_parameters(driver_ptr);
 269
 270     return false;
 271 }
 272
 273 /* destroy jack_driver_param_desc_t list created by jackctl_create_param_list() */
 274 static void
 275 jackctl_destroy_param_list(
 276     JSList * params)
 277 {
 278     JSList * next;
 279
 280     while (params)
 281     {
 282         next = params->next;
 283         free(params->data);
 284         free(params);
 285         params = next;
 286     }
 287 }
 288
 289 /* for drivers and internals are configured through jack_driver_param_t JSList */
 290 /* this function creates such list from a jackctl_parameter list */
 291 static JSList *
 292 jackctl_create_param_list(
 293     const JSList * paramlist)
 294 {
 295     jackctl_parameter * param_ptr;
 296     jack_driver_param_t * retparam_ptr;
 297     JSList * retparamlist;
 298
 299     retparamlist = NULL;
 300     while (paramlist != NULL)
 301     {
 302         param_ptr = (jackctl_parameter *)paramlist->data;
 303         if (param_ptr->is_set)
 304         {
 305             /* jack_info("setting driver parameter %p ...", parameter_ptr); */
 306             retparam_ptr = (jack_driver_param_t *)malloc(sizeof(jack_driver_param_t));
 307             if (retparam_ptr == NULL)
 308             {
 309                 jack_error ("Allocation of jack_driver_param_t structure failed");
 310                 goto destroy;
 311             }
 312
 313             retparam_ptr->character = param_ptr->id;
 314
 315             switch (param_ptr->type)
 316             {
 317             case JackParamInt:
 318                 retparam_ptr->value.i = param_ptr->value_ptr->i;
 319                 break;
 320             case JackParamUInt:
 321                 retparam_ptr->value.ui = param_ptr->value_ptr->ui;
 322                 break;
 323             case JackParamChar:
 324                 retparam_ptr->value.c = param_ptr->value_ptr->c;
 325                 break;
 326             case JackParamString:
 327                 strcpy(retparam_ptr->value.str, param_ptr->value_ptr->str);
 328                 break;
 329             case JackParamBool:
 330                 retparam_ptr->value.i = param_ptr->value_ptr->b;
 331                 break;
 332             default:
 333                 jack_error("Unknown parameter type %i", (int)param_ptr->type);
 334                 assert(0);
 335                 goto free;
 336             }
 337
 338             retparamlist = jack_slist_append(retparamlist, retparam_ptr);
 339         }
 340
 341         paramlist = paramlist->next;
 342     }
 343
 344     return retparamlist;
 345
 346 free:
 347     free(retparam_ptr);
 348 destroy:
 349     jackctl_destroy_param_list(retparamlist);
 350     return NULL;
 351 }
 352
 353 static int
 354 jackctl_drivers_load(
 355     struct jackctl_server * server_ptr)
 356 {
 357     struct jackctl_driver * driver_ptr;
 358     JSList *node_ptr;
 359     JSList *descriptor_node_ptr;
 360
 361     descriptor_node_ptr = jack_drivers_load(NULL);
 362     if (descriptor_node_ptr == NULL)
 363     {
 364         jack_error("Could not find any drivers in driver directory!");
 365         return false;
 366     }
 367
 368     while (descriptor_node_ptr != NULL)
 369     {
 370         driver_ptr = (struct jackctl_driver *)malloc(sizeof(struct jackctl_driver));
 371         if (driver_ptr == NULL)
 372         {
 373             jack_error("Memory allocation of jackctl_driver structure failed.");
 374             goto next;
 375         }
 376
 377         driver_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
 378         driver_ptr->parameters = NULL;
 379         driver_ptr->infos = NULL;
 380
 381         if (!jackctl_add_driver_parameters(driver_ptr))
 382         {
 383             assert(driver_ptr->parameters == NULL);
 384             free(driver_ptr);
 385             goto next;
 386         }
 387
 388         server_ptr->drivers = jack_slist_append(server_ptr->drivers, driver_ptr);
 389
 390     next:
 391         node_ptr = descriptor_node_ptr;
 392         descriptor_node_ptr = descriptor_node_ptr->next;
 393         free(node_ptr);
 394     }
 395
 396     return true;
 397 }
 398
 399 static
 400 void
 401 jackctl_server_free_drivers(
 402     struct jackctl_server * server_ptr)
 403 {
 404     JSList * next_node_ptr;
 405     struct jackctl_driver * driver_ptr;
 406
 407     while (server_ptr->drivers)
 408     {
 409         next_node_ptr = server_ptr->drivers->next;
 410         driver_ptr = (struct jackctl_driver *)server_ptr->drivers->data;
 411
 412         jackctl_free_driver_parameters(driver_ptr);
 413         free(driver_ptr->desc_ptr->params);
 414         free(driver_ptr->desc_ptr);
 415         free(driver_ptr);
 416
 417         free(server_ptr->drivers);
 418         server_ptr->drivers = next_node_ptr;
 419     }
 420 }
 421
 422 static int
 423 jackctl_internals_load(
 424     struct jackctl_server * server_ptr)
 425 {
 426     struct jackctl_internal * internal_ptr;
 427     JSList *node_ptr;
 428     JSList *descriptor_node_ptr;
 429
 430     descriptor_node_ptr = jack_internals_load(NULL);
 431     if (descriptor_node_ptr == NULL)
 432     {
 433         jack_error("Could not find any internals in driver directory!");
 434         return false;
 435     }
 436
 437     while (descriptor_node_ptr != NULL)
 438     {
 439         internal_ptr = (struct jackctl_internal *)malloc(sizeof(struct jackctl_internal));
 440         if (internal_ptr == NULL)
 441         {
 442             jack_error("Memory allocation of jackctl_driver structure failed.");
 443             goto next;
 444         }
 445
 446         internal_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
 447         internal_ptr->parameters = NULL;
 448         internal_ptr->refnum = -1;
 449
 450         if (!jackctl_add_driver_parameters((struct jackctl_driver *)internal_ptr))
 451         {
 452             assert(internal_ptr->parameters == NULL);
 453             free(internal_ptr);
 454             goto next;
 455         }
 456
 457         server_ptr->internals = jack_slist_append(server_ptr->internals, internal_ptr);
 458
 459     next:
 460         node_ptr = descriptor_node_ptr;
 461         descriptor_node_ptr = descriptor_node_ptr->next;
 462         free(node_ptr);
 463     }
 464
 465     return true;
 466 }
 467
 468 static
 469 void
 470 jackctl_server_free_internals(
 471     struct jackctl_server * server_ptr)
 472 {
 473     JSList * next_node_ptr;
 474     struct jackctl_internal * internal_ptr;
 475
 476     while (server_ptr->internals)
 477     {
 478         next_node_ptr = server_ptr->internals->next;
 479         internal_ptr = (struct jackctl_internal *)server_ptr->internals->data;
 480
 481         jackctl_free_driver_parameters((struct jackctl_driver *)internal_ptr);
 482         free(internal_ptr->desc_ptr->params);
 483         free(internal_ptr->desc_ptr);
 484         free(internal_ptr);
 485
 486         free(server_ptr->internals);
 487         server_ptr->internals = next_node_ptr;
 488     }
 489 }
 490
 491 static
 492 void
 493 jackctl_server_free_parameters(
 494     struct jackctl_server * server_ptr)
 495 {
 496     JSList * next_node_ptr;
 497
 498     while (server_ptr->parameters)
 499     {
 500         next_node_ptr = server_ptr->parameters->next;
 501         free(server_ptr->parameters->data);
 502         free(server_ptr->parameters);
 503         server_ptr->parameters = next_node_ptr;
 504     }
 505 }
 506
 507 #ifdef WIN32
 508
 509 struct jackctl_sigmask
 510 {
 511     HANDLE wait_event;
 512 };
 513
 514 static jackctl_sigmask sigmask;
 515
 516 static void signal_handler(int signum)
 517 {
 518     printf("Jack main caught signal %d\n", signum);
 519     (void) signal(SIGINT, SIG_DFL);
 520     SetEvent(sigmask.wait_event);
 521 }
 522
 523 jackctl_sigmask_t *
 524 jackctl_setup_signals(
 525     unsigned int flags)
 526 {
 527     if ((sigmask.wait_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
 528         jack_error("CreateEvent fails err = %ld", GetLastError());
 529         return 0;
 530     }
 531
 532     (void) signal(SIGINT, signal_handler);
 533     (void) signal(SIGABRT, signal_handler);
 534     (void) signal(SIGTERM, signal_handler);
 535
 536     return &sigmask;
 537 }
 538
 539 void jackctl_wait_signals(jackctl_sigmask_t * signals)
 540 {
 541     if (WaitForSingleObject(signals->wait_event, INFINITE) != WAIT_OBJECT_0) {
 542         jack_error("WaitForSingleObject fails err = %ld", GetLastError());
 543     }
 544 }
 545
 546 #else
 547
 548 struct jackctl_sigmask
 549 {
 550     sigset_t signals;
 551 };
 552
 553 static jackctl_sigmask sigmask;
 554
 555 static
 556 void
 557 signal_handler(int sig)
 558 {
 559     /* this is used by the child (active) process, but it never
 560        gets called unless we are already shutting down after
 561        another signal.
 562     */
 563     char buf[64];
 564     snprintf(buf, sizeof(buf), "Received signal %d during shutdown (ignored)\n", sig);
 565 }
 566
 567 SERVER_EXPORT jackctl_sigmask_t *
 568 jackctl_setup_signals(
 569     unsigned int flags)
 570 {
 571     sigset_t allsignals;
 572     struct sigaction action;
 573     int i;
 574
 575     /* ensure that we are in our own process group so that
 576        kill (SIG, -pgrp) does the right thing.
 577     */
 578
 579     setsid();
 580
 581     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 582
 583     /* what's this for?
 584
 585        POSIX says that signals are delivered like this:
 586
 587        * if a thread has blocked that signal, it is not
 588            a candidate to receive the signal.
 589            * of all threads not blocking the signal, pick
 590            one at random, and deliver the signal.
 591
 592            this means that a simple-minded multi-threaded program can
 593            expect to get POSIX signals delivered randomly to any one
 594            of its threads,
 595
 596        here, we block all signals that we think we might receive
 597        and want to catch. all "child" threads will inherit this
 598        setting. if we create a thread that calls sigwait() on the
 599        same set of signals, implicitly unblocking all those
 600        signals. any of those signals that are delivered to the
 601        process will be delivered to that thread, and that thread
 602        alone. this makes cleanup for a signal-driven exit much
 603        easier, since we know which thread is doing it and more
 604        importantly, we are free to call async-unsafe functions,
 605        because the code is executing in normal thread context
 606        after a return from sigwait().
 607     */
 608
 609     sigemptyset(&sigmask.signals);
 610     sigaddset(&sigmask.signals, SIGHUP);
 611     sigaddset(&sigmask.signals, SIGINT);
 612     sigaddset(&sigmask.signals, SIGQUIT);
 613     sigaddset(&sigmask.signals, SIGPIPE);
 614     sigaddset(&sigmask.signals, SIGTERM);
 615     sigaddset(&sigmask.signals, SIGUSR1);
 616     sigaddset(&sigmask.signals, SIGUSR2);
 617
 618     /* all child threads will inherit this mask unless they
 619      * explicitly reset it
 620      */
 621
 622     pthread_sigmask(SIG_BLOCK, &sigmask.signals, 0);
 623
 624     /* install a do-nothing handler because otherwise pthreads
 625        behaviour is undefined when we enter sigwait.
 626     */
 627
 628     sigfillset(&allsignals);
 629     action.sa_handler = signal_handler;
 630     action.sa_mask = allsignals;
 631     action.sa_flags = SA_RESTART|SA_RESETHAND;
 632
 633     for (i = 1; i < NSIG; i++)
 634     {
 635         if (sigismember (&sigmask.signals, i))
 636         {
 637             sigaction(i, &action, 0);
 638         }
 639     }
 640
 641     return &sigmask;
 642 }
 643
 644 SERVER_EXPORT void
 645 jackctl_wait_signals(jackctl_sigmask_t * sigmask)
 646 {
 647     int sig;
 648     bool waiting = true;
 649
 650     while (waiting) {
 651     #if defined(sun) && !defined(__sun__) // SUN compiler only, to check
 652         sigwait(&sigmask->signals);
 653     #else
 654         sigwait(&sigmask->signals, &sig);
 655     #endif
 656         fprintf(stderr, "Jack main caught signal %d\n", sig);
 657
 658         switch (sig) {
 659             case SIGUSR1:
 660                 //jack_dump_configuration(engine, 1);
 661                 break;
 662             case SIGUSR2:
 663                 // driver exit
 664                 waiting = false;
 665                 break;
 666             case SIGTTOU:
 667                 break;
 668             default:
 669                 waiting = false;
 670                 break;
 671         }
 672     }
 673
 674     if (sig != SIGSEGV) {
 675         // unblock signals so we can see them during shutdown.
 676         // this will help prod developers not to lose sight of
 677         // bugs that cause segfaults etc. during shutdown.
 678         sigprocmask(SIG_UNBLOCK, &sigmask->signals, 0);
 679     }
 680 }
 681 #endif
 682
 683 static
 684 jack_driver_param_constraint_desc_t *
 685 get_realtime_priority_constraint()
 686 {
 687     jack_driver_param_constraint_desc_t * constraint_ptr;
 688     int min, max;
 689
 690     if (!jack_get_thread_realtime_priority_range(&min, &max))
 691     {
 692         return NULL;
 693     }
 694
 695     //jack_info("realtime priority range is (%d,%d)", min, max);
 696
 697     constraint_ptr = (jack_driver_param_constraint_desc_t *)calloc(1, sizeof(jack_driver_param_value_enum_t));
 698     if (constraint_ptr == NULL)
 699     {
 700         jack_error("Cannot allocate memory for jack_driver_param_constraint_desc_t structure.");
 701         return NULL;
 702     }
 703     constraint_ptr->flags = JACK_CONSTRAINT_FLAG_RANGE;
 704
 705     constraint_ptr->constraint.range.min.i = min;
 706     constraint_ptr->constraint.range.max.i = max;
 707
 708     return constraint_ptr;
 709 }
 710
 711 SERVER_EXPORT jackctl_server_t * jackctl_server_create(
 712     bool (* on_device_acquire)(const char * device_name),
 713     void (* on_device_release)(const char * device_name))
 714 {
 715     struct jackctl_server * server_ptr;
 716     union jackctl_parameter_value value;
 717
 718     server_ptr = (struct jackctl_server *)malloc(sizeof(struct jackctl_server));
 719     if (server_ptr == NULL)
 720     {
 721         jack_error("Cannot allocate memory for jackctl_server structure.");
 722         goto fail;
 723     }
 724
 725     server_ptr->drivers = NULL;
 726     server_ptr->internals = NULL;
 727     server_ptr->parameters = NULL;
 728     server_ptr->engine = NULL;
 729
 730     strcpy(value.str, JACK_DEFAULT_SERVER_NAME);
 731     if (jackctl_add_parameter(
 732             &server_ptr->parameters,
 733             "name",
 734             "Server name to use.",
 735             "",
 736             JackParamString,
 737             &server_ptr->name,
 738             &server_ptr->default_name,
 739             value) == NULL)
 740     {
 741         goto fail_free_parameters;
 742     }
 743
 744     value.b = true;
 745     if (jackctl_add_parameter(
 746             &server_ptr->parameters,
 747             "realtime",
 748             "Whether to use realtime mode.",
 749             "Use realtime scheduling. This is needed for reliable low-latency performance. On most systems, it requires JACK to run with special scheduler and memory allocation privileges, which may be obtained in several ways. On Linux you should use PAM.",
 750             JackParamBool,
 751             &server_ptr->realtime,
 752             &server_ptr->default_realtime,
 753             value) == NULL)
 754     {
 755         goto fail_free_parameters;
 756     }
 757
 758     value.i = 10;
 759     if (jackctl_add_parameter(
 760             &server_ptr->parameters,
 761             "realtime-priority",
 762             "Scheduler priority when running in realtime mode.",
 763             "",
 764             JackParamInt,
 765             &server_ptr->realtime_priority,
 766             &server_ptr->default_realtime_priority,
 767             value,
 768             get_realtime_priority_constraint()) == NULL)
 769     {
 770         goto fail_free_parameters;
 771     }
 772
 773     value.b = false;
 774     if (jackctl_add_parameter(
 775             &server_ptr->parameters,
 776             "temporary",
 777             "Exit once all clients have closed their connections.",
 778             "",
 779             JackParamBool,
 780             &server_ptr->temporary,
 781             &server_ptr->default_temporary,
 782             value) == NULL)
 783     {
 784         goto fail_free_parameters;
 785     }
 786
 787     value.b = false;
 788     if (jackctl_add_parameter(
 789             &server_ptr->parameters,
 790             "verbose",
 791             "Verbose mode.",
 792             "",
 793             JackParamBool,
 794             &server_ptr->verbose,
 795             &server_ptr->default_verbose,
 796             value) == NULL)
 797     {
 798         goto fail_free_parameters;
 799     }
 800
 801     value.i = 0;
 802     if (jackctl_add_parameter(
 803             &server_ptr->parameters,
 804             "client-timeout",
 805             "Client timeout limit in milliseconds.",
 806             "",
 807             JackParamInt,
 808             &server_ptr->client_timeout,
 809             &server_ptr->default_client_timeout,
 810             value) == NULL)
 811     {
 812         goto fail_free_parameters;
 813     }
 814
 815     value.ui = 0;
 816     if (jackctl_add_parameter(
 817             &server_ptr->parameters,
 818             "clock-source",
 819             "Clocksource type : c(ycle) | h(pet) | s(ystem).",
 820             "",
 821             JackParamUInt,
 822             &server_ptr->clock_source,
 823             &server_ptr->default_clock_source,
 824             value) == NULL)
 825     {
 826         goto fail_free_parameters;
 827     }
 828
 829     value.ui = PORT_NUM;
 830     if (jackctl_add_parameter(
 831           &server_ptr->parameters,
 832           "port-max",
 833           "Maximum number of ports.",
 834           "",
 835           JackParamUInt,
 836           &server_ptr->port_max,
 837           &server_ptr->default_port_max,
 838           value) == NULL)
 839     {
 840         goto fail_free_parameters;
 841     }
 842
 843     value.b = false;
 844     if (jackctl_add_parameter(
 845             &server_ptr->parameters,
 846             "replace-registry",
 847             "Replace shared memory registry.",
 848             "",
 849             JackParamBool,
 850             &server_ptr->replace_registry,
 851             &server_ptr->default_replace_registry,
 852             value) == NULL)
 853     {
 854         goto fail_free_parameters;
 855     }
 856
 857     value.b = false;
 858     if (jackctl_add_parameter(
 859             &server_ptr->parameters,
 860             "sync",
 861             "Use server synchronous mode.",
 862             "",
 863             JackParamBool,
 864             &server_ptr->sync,
 865             &server_ptr->default_sync,
 866             value) == NULL)
 867     {
 868         goto fail_free_parameters;
 869     }
 870
 871     JackServerGlobals::on_device_acquire = on_device_acquire;
 872     JackServerGlobals::on_device_release = on_device_release;
 873
 874     if (!jackctl_drivers_load(server_ptr))
 875     {
 876         goto fail_free_parameters;
 877     }
 878
 879     /* Allowed to fail */
 880     jackctl_internals_load(server_ptr);
 881
 882     return server_ptr;
 883
 884 fail_free_parameters:
 885     jackctl_server_free_parameters(server_ptr);
 886
 887     free(server_ptr);
 888
 889 fail:
 890     return NULL;
 891 }
 892
 893 SERVER_EXPORT void jackctl_server_destroy(jackctl_server *server_ptr)
 894 {
 895     if (server_ptr) {
 896         jackctl_server_free_drivers(server_ptr);
 897         jackctl_server_free_internals(server_ptr);
 898         jackctl_server_free_parameters(server_ptr);
 899         free(server_ptr);
 900     }
 901 }
 902
 903 SERVER_EXPORT const JSList * jackctl_server_get_drivers_list(jackctl_server *server_ptr)
 904 {
 905     return (server_ptr) ? server_ptr->drivers : NULL;
 906 }
 907
 908 SERVER_EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
 909 {
 910     if (server_ptr) {
 911         server_ptr->engine->Stop();
 912         return true;
 913     } else {
 914         return false;
 915     }
 916 }
 917
 918 SERVER_EXPORT bool jackctl_server_close(jackctl_server *server_ptr)
 919 {
 920     if (server_ptr) {
 921         server_ptr->engine->Close();
 922         delete server_ptr->engine;
 923
 924         /* clean up shared memory and files from this server instance */
 925         jack_log("Cleaning up shared memory");
 926
 927         jack_cleanup_shm();
 928
 929         jack_log("Cleaning up files");
 930
 931         JackTools::CleanupFiles(server_ptr->name.str);
 932
 933         jack_log("Unregistering server `%s'", server_ptr->name.str);
 934
 935         jack_unregister_server(server_ptr->name.str);
 936
 937         server_ptr->engine = NULL;
 938
 939         return true;
 940     } else {
 941         return false;
 942     }
 943 }
 944
 945 SERVER_EXPORT const JSList * jackctl_server_get_parameters(jackctl_server *server_ptr)
 946 {
 947     return (server_ptr) ? server_ptr->parameters : NULL;
 948 }
 949
 950 SERVER_EXPORT bool
 951 jackctl_server_open(
 952     jackctl_server *server_ptr,
 953     jackctl_driver *driver_ptr)
 954 {
 955     JSList * paramlist = NULL;
 956
 957     try {
 958
 959         if (!server_ptr || !driver_ptr) {
 960             return false;
 961         }
 962
 963         int rc = jack_register_server(server_ptr->name.str, server_ptr->replace_registry.b);
 964         switch (rc)
 965         {
 966         case EEXIST:
 967             jack_error("`%s' server already active", server_ptr->name.str);
 968             goto fail;
 969         case ENOSPC:
 970             jack_error("Too many servers already active");
 971             goto fail;
 972         case ENOMEM:
 973             jack_error("No access to shm registry");
 974             goto fail;
 975         }
 976
 977         jack_log("Server `%s' registered", server_ptr->name.str);
 978
 979         /* clean up shared memory and files from any previous
 980          * instance of this server name */
 981         jack_cleanup_shm();
 982         JackTools::CleanupFiles(server_ptr->name.str);
 983
 984         if (!server_ptr->realtime.b && server_ptr->client_timeout.i == 0) {
 985             server_ptr->client_timeout.i = 500; /* 0.5 sec; usable when non realtime. */
 986         }
 987
 988         /* check port max value before allocating server */
 989         if (server_ptr->port_max.ui > PORT_NUM_MAX) {
 990             jack_error("Jack server started with too much ports %d (when port max can be %d)", server_ptr->port_max.ui, PORT_NUM_MAX);
 991             goto fail;
 992         }
 993
 994         /* get the engine/driver started */
 995         server_ptr->engine = new JackServer(
 996             server_ptr->sync.b,
 997             server_ptr->temporary.b,
 998             server_ptr->client_timeout.i,
 999             server_ptr->realtime.b,
1000             server_ptr->realtime_priority.i,
1001             server_ptr->port_max.ui,
1002             server_ptr->verbose.b,
1003             (jack_timer_type_t)server_ptr->clock_source.ui,
1004             server_ptr->name.str);
1005         if (server_ptr->engine == NULL)
1006         {
1007             jack_error("Failed to create new JackServer object");
1008             goto fail_unregister;
1009         }
1010
1011         paramlist = jackctl_create_param_list(driver_ptr->parameters);
1012         if (paramlist == NULL) goto fail_delete;
1013         rc = server_ptr->engine->Open(driver_ptr->desc_ptr, paramlist);
1014         jackctl_destroy_param_list(paramlist);
1015         if (rc < 0)
1016         {
1017             jack_error("JackServer::Open failed with %d", rc);
1018             goto fail_delete;
1019         }
1020
1021         return true;
1022
1023     } catch (std::exception e) {
1024         jack_error("jackctl_server_open error...");
1025         jackctl_destroy_param_list(paramlist);
1026     }
1027
1028 fail_delete:
1029     delete server_ptr->engine;
1030     server_ptr->engine = NULL;
1031
1032 fail_unregister:
1033     jack_log("Cleaning up shared memory");
1034
1035     jack_cleanup_shm();
1036
1037     jack_log("Cleaning up files");
1038
1039     JackTools::CleanupFiles(server_ptr->name.str);
1040
1041     jack_log("Unregistering server `%s'", server_ptr->name.str);
1042
1043     jack_unregister_server(server_ptr->name.str);
1044
1045 fail:
1046     return false;
1047 }
1048
1049 SERVER_EXPORT bool
1050 jackctl_server_start(
1051     jackctl_server *server_ptr)
1052 {
1053     if (!server_ptr) {
1054         return false;
1055     } else {
1056         int rc = server_ptr->engine->Start();
1057         bool result = rc >= 0;
1058         if (! result)
1059         {
1060             jack_error("JackServer::Start() failed with %d", rc);
1061         }
1062         return result;
1063     }
1064 }
1065
1066 SERVER_EXPORT const char * jackctl_driver_get_name(jackctl_driver *driver_ptr)
1067 {
1068     return (driver_ptr) ? driver_ptr->desc_ptr->name : NULL;
1069 }
1070
1071 SERVER_EXPORT jackctl_driver_type_t jackctl_driver_get_type(jackctl_driver *driver_ptr)
1072 {
1073     return (driver_ptr) ? (jackctl_driver_type_t)driver_ptr->desc_ptr->type : (jackctl_driver_type_t)0;
1074 }
1075
1076 SERVER_EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_ptr)
1077 {
1078     return (driver_ptr) ? driver_ptr->parameters : NULL;
1079 }
1080
1081 SERVER_EXPORT jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver *driver_ptr)
1082 {
1083     return (driver_ptr) ? driver_ptr->desc_ptr : NULL;
1084 }
1085
1086 SERVER_EXPORT const char * jackctl_parameter_get_name(jackctl_parameter *parameter_ptr)
1087 {
1088     return (parameter_ptr) ? parameter_ptr->name : NULL;
1089 }
1090
1091 SERVER_EXPORT const char * jackctl_parameter_get_short_description(jackctl_parameter *parameter_ptr)
1092 {
1093     return (parameter_ptr) ? parameter_ptr->short_description : NULL;
1094 }
1095
1096 SERVER_EXPORT const char * jackctl_parameter_get_long_description(jackctl_parameter *parameter_ptr)
1097 {
1098     return (parameter_ptr) ? parameter_ptr->long_description : NULL;
1099 }
1100
1101 SERVER_EXPORT bool jackctl_parameter_has_range_constraint(jackctl_parameter *parameter_ptr)
1102 {
1103     return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_RANGE) != 0) : false;
1104 }
1105
1106 SERVER_EXPORT bool jackctl_parameter_has_enum_constraint(jackctl_parameter *parameter_ptr)
1107 {
1108     return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_RANGE) == 0): false;
1109 }
1110
1111 SERVER_EXPORT uint32_t jackctl_parameter_get_enum_constraints_count(jackctl_parameter *parameter_ptr)
1112 {
1113     if (!parameter_ptr) {
1114         return NULL;
1115     }
1116
1117     if (!jackctl_parameter_has_enum_constraint(parameter_ptr))
1118     {
1119         return 0;
1120     }
1121
1122     return parameter_ptr->constraint_ptr->constraint.enumeration.count;
1123  }
1124
1125 SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_enum_constraint_value(jackctl_parameter *parameter_ptr, uint32_t index)
1126 {
1127     jack_driver_param_value_t * value_ptr;
1128     union jackctl_parameter_value jackctl_value;
1129
1130     if (!parameter_ptr) {
1131         memset(&jackctl_value, 0, sizeof(jackctl_value));
1132         return jackctl_value;
1133     }
1134
1135     value_ptr = &parameter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].value;
1136
1137     switch (parameter_ptr->type)
1138     {
1139     case JackParamInt:
1140         jackctl_value.i = value_ptr->i;
1141         break;
1142     case JackParamUInt:
1143         jackctl_value.ui = value_ptr->ui;
1144         break;
1145     case JackParamChar:
1146         jackctl_value.c = value_ptr->c;
1147         break;
1148     case JackParamString:
1149         strcpy(jackctl_value.str, value_ptr->str);
1150         break;
1151     default:
1152         jack_error("Bad driver parameter type %i (enum constraint)", (int)parameter_ptr->type);
1153         assert(0);
1154     }
1155
1156     return jackctl_value;
1157 }
1158
1159 SERVER_EXPORT const char * jackctl_parameter_get_enum_constraint_description(jackctl_parameter *parameter_ptr, uint32_t index)
1160 {
1161     return (parameter_ptr) ? parameter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].short_desc : NULL;
1162 }
1163
1164 SERVER_EXPORT void jackctl_parameter_get_range_constraint(jackctl_parameter *parameter_ptr, union jackctl_parameter_value * min_ptr, union jackctl_parameter_value * max_ptr)
1165 {
1166     if (!parameter_ptr || !min_ptr || !max_ptr) {
1167         return;
1168     }
1169
1170     switch (parameter_ptr->type)
1171     {
1172     case JackParamInt:
1173         min_ptr->i = parameter_ptr->constraint_ptr->constraint.range.min.i;
1174         max_ptr->i = parameter_ptr->constraint_ptr->constraint.range.max.i;
1175         return;
1176     case JackParamUInt:
1177         min_ptr->ui = parameter_ptr->constraint_ptr->constraint.range.min.ui;
1178         max_ptr->ui = parameter_ptr->constraint_ptr->constraint.range.max.ui;
1179         return;
1180     default:
1181         jack_error("Bad driver parameter type %i (range constraint)", (int)parameter_ptr->type);
1182         assert(0);
1183     }
1184 }
1185
1186 SERVER_EXPORT bool jackctl_parameter_constraint_is_strict(jackctl_parameter_t * parameter_ptr)
1187 {
1188     return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_STRICT) != 0) : false;
1189 }
1190
1191 SERVER_EXPORT bool jackctl_parameter_constraint_is_fake_value(jackctl_parameter_t * parameter_ptr)
1192 {
1193     return (parameter_ptr) ? (parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_FAKE_VALUE) != 0) : false;
1194 }
1195
1196 SERVER_EXPORT jackctl_param_type_t jackctl_parameter_get_type(jackctl_parameter *parameter_ptr)
1197 {
1198     return (parameter_ptr) ? parameter_ptr->type : (jackctl_param_type_t)0;
1199 }
1200
1201 SERVER_EXPORT char jackctl_parameter_get_id(jackctl_parameter_t * parameter_ptr)
1202 {
1203     return (parameter_ptr) ? parameter_ptr->id : 0;
1204 }
1205
1206 SERVER_EXPORT bool jackctl_parameter_is_set(jackctl_parameter *parameter_ptr)
1207 {
1208     return (parameter_ptr) ? parameter_ptr->is_set : false;
1209 }
1210
1211 SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_value(jackctl_parameter *parameter_ptr)
1212 {
1213     if (parameter_ptr)  {
1214         return *parameter_ptr->value_ptr;
1215     } else  {
1216         union jackctl_parameter_value jackctl_value;
1217         memset(&jackctl_value, 0, sizeof(jackctl_value));
1218         return jackctl_value;
1219     }
1220 }
1221
1222 SERVER_EXPORT bool jackctl_parameter_reset(jackctl_parameter *parameter_ptr)
1223 {
1224     if (!parameter_ptr) {
1225         return NULL;
1226     }
1227
1228     if (!parameter_ptr->is_set)
1229     {
1230         return true;
1231     }
1232
1233     parameter_ptr->is_set = false;
1234
1235     *parameter_ptr->value_ptr = *parameter_ptr->default_value_ptr;
1236
1237     return true;
1238 }
1239
1240 SERVER_EXPORT bool jackctl_parameter_set_value(jackctl_parameter *parameter_ptr, const union jackctl_parameter_value * value_ptr)
1241 {
1242     if (!parameter_ptr || !value_ptr) {
1243         return NULL;
1244     }
1245
1246     parameter_ptr->is_set = true;
1247     *parameter_ptr->value_ptr = *value_ptr;
1248
1249     return true;
1250 }
1251
1252 SERVER_EXPORT union jackctl_parameter_value jackctl_parameter_get_default_value(jackctl_parameter *parameter_ptr)
1253 {
1254     if (parameter_ptr)  {
1255         return *parameter_ptr->default_value_ptr;
1256     } else  {
1257         union jackctl_parameter_value jackctl_value;
1258         memset(&jackctl_value, 0, sizeof(jackctl_value));
1259         return jackctl_value;
1260     }
1261 }
1262
1263 // Internals clients
1264
1265 SERVER_EXPORT const JSList * jackctl_server_get_internals_list(jackctl_server *server_ptr)
1266 {
1267     return (server_ptr) ? server_ptr->internals : NULL;
1268 }
1269
1270 SERVER_EXPORT const char * jackctl_internal_get_name(jackctl_internal *internal_ptr)
1271 {
1272     return (internal_ptr) ? internal_ptr->desc_ptr->name : NULL;
1273 }
1274
1275 SERVER_EXPORT const JSList * jackctl_internal_get_parameters(jackctl_internal *internal_ptr)
1276 {
1277     return (internal_ptr) ? internal_ptr->parameters : NULL;
1278 }
1279
1280 SERVER_EXPORT bool jackctl_server_load_internal(
1281     jackctl_server * server_ptr,
1282     jackctl_internal * internal)
1283 {
1284     if (!server_ptr || !internal) {
1285         return false;
1286     }
1287
1288     int status;
1289     if (server_ptr->engine != NULL) {
1290         JSList * paramlist = jackctl_create_param_list(internal->parameters);
1291         if (paramlist == NULL) return false;
1292         server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, paramlist, JackNullOption, &internal->refnum, -1, &status);
1293         jackctl_destroy_param_list(paramlist);
1294         return (internal->refnum > 0);
1295     } else {
1296         return false;
1297     }
1298 }
1299
1300 SERVER_EXPORT bool jackctl_server_unload_internal(
1301     jackctl_server * server_ptr,
1302     jackctl_internal * internal)
1303 {
1304     if (!server_ptr || !internal) {
1305         return false;
1306     }
1307
1308     int status;
1309     if (server_ptr->engine != NULL && internal->refnum > 0) {
1310         // Client object is internally kept in JackEngine, and will be deallocated in InternalClientUnload
1311         return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
1312     } else {
1313         return false;
1314     }
1315 }
1316
1317 SERVER_EXPORT bool jackctl_server_add_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
1318 {
1319     if (server_ptr && server_ptr->engine) {
1320         if (server_ptr->engine->IsRunning()) {
1321             jack_error("Cannot add a slave in a running server");
1322             return false;
1323         } else {
1324             JSList * paramlist = jackctl_create_param_list(driver_ptr->parameters);
1325             if (paramlist == NULL) return false;
1326             JackDriverInfo* info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, paramlist);
1327             jackctl_destroy_param_list(paramlist);
1328             if (info) {
1329                 driver_ptr->infos = jack_slist_append(driver_ptr->infos, info);
1330                 return true;
1331             } else {
1332                 return false;
1333             }
1334         }
1335     } else {
1336         return false;
1337     }
1338 }
1339
1340 SERVER_EXPORT bool jackctl_server_remove_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
1341 {
1342     if (server_ptr && server_ptr->engine) {
1343         if (server_ptr->engine->IsRunning()) {
1344             jack_error("Cannot remove a slave from a running server");
1345             return false;
1346         } else {
1347             if (driver_ptr->infos) {
1348                 JackDriverInfo* info = (JackDriverInfo*)driver_ptr->infos->data;
1349                 assert(info);
1350                 driver_ptr->infos = jack_slist_remove(driver_ptr->infos, info);
1351                 server_ptr->engine->RemoveSlave(info);
1352                 delete info;
1353                 return true;
1354             } else {
1355                 return false;
1356             }
1357         }
1358     } else {
1359         return false;
1360     }
1361 }
1362
1363 SERVER_EXPORT bool jackctl_server_switch_master(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
1364 {
1365     if (server_ptr && server_ptr->engine) {
1366         JSList * paramlist = jackctl_create_param_list(driver_ptr->parameters);
1367         if (paramlist == NULL) return false;
1368         jackctl_destroy_param_list(paramlist);
1369         bool ret = (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, paramlist) == 0);
1370         jackctl_destroy_param_list(paramlist);
1371         return ret;
1372     } else {
1373         return false;
1374     }
1375 }
1376
1377