common/Jackdmp.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2013 Grame
   4 Copyright (C) 2016-2019 Grame
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 */
  21
  22 #include <iostream>
  23 #include <assert.h>
  24 #include <cassert>
  25 #include <csignal>
  26 #include <sys/types.h>
  27 #include <getopt.h>
  28 #include <cstring>
  29 #include <cstdio>
  30 #include <list>
  31
  32 #include "types.h"
  33 #include "jack.h"
  34 #include "control.h"
  35 #include "JackConstants.h"
  36 #include "JackPlatformPlug.h"
  37 #ifdef __ANDROID__
  38 #include "JackControlAPIAndroid.h"
  39 #endif
  40
  41 #if defined(JACK_DBUS) && defined(__linux__)
  42 #include <cstdlib>
  43 #include <dbus/dbus.h>
  44 #include "audio_reserve.h"
  45 #endif
  46
  47 #if HAVE_SYSTEMD
  48 #include <systemd/sd-daemon.h>
  49 #endif
  50
  51 /*
  52 This is a simple port of the old jackdmp.cpp file to use the new jack2 control API. Available options for the server
  53 are "hard-coded" in the source. A much better approach would be to use the control API to:
  54 - dynamically retrieve available server parameters and then prepare to parse them
  55 - get available drivers and their possible parameters, then prepare to parse them.
  56 */
  57
  58 #ifdef __APPLE__
  59 #include <CoreFoundation/CFNotificationCenter.h>
  60 #include <CoreFoundation/CoreFoundation.h>
  61
  62 static void notify_server_start(const char* server_name)
  63 {
  64     // Send notification to be used in the JackRouter plugin
  65     CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
  66     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
  67             CFSTR("com.grame.jackserver.start"),
  68             ref,
  69             NULL,
  70             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
  71     CFRelease(ref);
  72 }
  73
  74 static void notify_server_stop(const char* server_name)
  75 {
  76     // Send notification to be used in the JackRouter plugin
  77     CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
  78     CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
  79             CFSTR("com.grame.jackserver.stop"),
  80             ref1,
  81             NULL,
  82             kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
  83     CFRelease(ref1);
  84 }
  85
  86 #else
  87
  88 static void notify_server_start(const char* server_name)
  89 {}
  90 static void notify_server_stop(const char* server_name)
  91 {}
  92
  93 #endif
  94
  95 static void copyright(FILE* file)
  96 {
  97     fprintf(file, "jackdmp " VERSION "\n"
  98             "Copyright 2001-2005 Paul Davis and others.\n"
  99             "Copyright 2004-2016 Grame.\n"
 100             "Copyright 2016-2021 Filipe Coelho.\n"
 101             "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
 102             "This is free software, and you are welcome to redistribute it\n"
 103             "under certain conditions; see the file COPYING for details\n");
 104 }
 105
 106 static jackctl_driver_t * jackctl_server_get_driver(jackctl_server_t *server, const char *driver_name)
 107 {
 108     const JSList * node_ptr = jackctl_server_get_drivers_list(server);
 109
 110     while (node_ptr) {
 111         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0) {
 112             return (jackctl_driver_t *)node_ptr->data;
 113         }
 114         node_ptr = jack_slist_next(node_ptr);
 115     }
 116
 117     return NULL;
 118 }
 119
 120 static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
 121 {
 122     const JSList * node_ptr = jackctl_server_get_internals_list(server);
 123
 124     while (node_ptr) {
 125         if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
 126             return (jackctl_internal_t *)node_ptr->data;
 127         }
 128         node_ptr = jack_slist_next(node_ptr);
 129     }
 130
 131     return NULL;
 132 }
 133
 134 static jackctl_parameter_t * jackctl_get_parameter(const JSList * parameters_list, const char * parameter_name)
 135 {
 136     while (parameters_list) {
 137         if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0) {
 138             return (jackctl_parameter_t *)parameters_list->data;
 139         }
 140         parameters_list = jack_slist_next(parameters_list);
 141     }
 142
 143     return NULL;
 144 }
 145
 146 #ifdef __ANDROID__
 147 static void jackctl_server_switch_master_dummy(jackctl_server_t * server_ctl, char * master_driver_name)
 148 {
 149     static bool is_dummy_driver = false;
 150     if(!strcmp(master_driver_name, "dummy")) {
 151         return;
 152     }
 153     jackctl_driver_t * driver_ctr;
 154     if(is_dummy_driver) {
 155         is_dummy_driver = false;
 156         driver_ctr = jackctl_server_get_driver(server_ctl, master_driver_name);
 157     } else {
 158         is_dummy_driver = true;
 159         driver_ctr = jackctl_server_get_driver(server_ctl, "dummy");
 160     }
 161     jackctl_server_switch_master(server_ctl, driver_ctr);
 162 }
 163 #endif
 164
 165 static void print_server_drivers(jackctl_server_t *server, FILE* file)
 166 {
 167     const JSList * node_ptr = jackctl_server_get_drivers_list(server);
 168
 169     fprintf(file, "Available backends:\n");
 170
 171     while (node_ptr) {
 172         jackctl_driver_t* driver = (jackctl_driver_t *)node_ptr->data;
 173         fprintf(file, "      %s (%s)\n", jackctl_driver_get_name(driver), (jackctl_driver_get_type(driver) == JackMaster) ? "master" : "slave");
 174         node_ptr = jack_slist_next(node_ptr);
 175     }
 176     fprintf(file, "\n");
 177 }
 178
 179 static void print_server_internals(jackctl_server_t *server, FILE* file)
 180 {
 181     const JSList * node_ptr = jackctl_server_get_internals_list(server);
 182
 183     fprintf(file, "Available internals:\n");
 184
 185     while (node_ptr) {
 186         jackctl_internal_t* internal = (jackctl_internal_t *)node_ptr->data;
 187         fprintf(file, "      %s\n", jackctl_internal_get_name(internal));
 188         node_ptr = jack_slist_next(node_ptr);
 189     }
 190     fprintf(file, "\n");
 191 }
 192
 193 static void usage(FILE* file, jackctl_server_t *server, bool full = true)
 194 {
 195     jackctl_parameter_t * param;
 196     const JSList * server_parameters;
 197     uint32_t i;
 198     union jackctl_parameter_value value;
 199
 200     fprintf(file, "\n"
 201             "Usage: jackdmp [ --no-realtime OR -r ]\n"
 202             "               [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
 203             "      (the two previous arguments are mutually exclusive. The default is --realtime)\n"
 204             "               [ --name OR -n server-name ]\n"
 205             "               [ --timeout OR -t client-timeout-in-msecs ]\n"
 206             "               [ --loopback OR -L loopback-port-number ]\n"
 207             "               [ --port-max OR -p maximum-number-of-ports]\n"
 208             "               [ --slave-backend OR -X slave-backend-name ]\n"
 209             "               [ --internal-client OR -I internal-client-name ]\n"
 210             "               [ --internal-session-file OR -C internal-session-file ]\n"
 211             "               [ --verbose OR -v ]\n"
 212 #ifdef __linux__
 213             "               [ --clocksource OR -c [ h(pet) | s(ystem) ]\n"
 214 #endif
 215             "               [ --autoconnect OR -a <modechar>]\n");
 216
 217     server_parameters = jackctl_server_get_parameters(server);
 218     param = jackctl_get_parameter(server_parameters, "self-connect-mode");
 219     fprintf(file,
 220             "                 where <modechar> is one of:\n");
 221     for (i = 0; i < jackctl_parameter_get_enum_constraints_count(param); i++)
 222     {
 223         value = jackctl_parameter_get_enum_constraint_value(param, i);
 224         fprintf(file, "                   '%c' - %s", value.c, jackctl_parameter_get_enum_constraint_description(param, i));
 225         if (value.c == JACK_DEFAULT_SELF_CONNECT_MODE)
 226         {
 227             fprintf(file, " (default)");
 228         }
 229         fprintf(file, "\n");
 230     }
 231
 232     fprintf(file,
 233             "               [ --replace-registry ]\n"
 234             "               [ --silent OR -s ]\n"
 235             "               [ --sync OR -S ]\n"
 236             "               [ --temporary OR -T ]\n"
 237             "               [ --version OR -V ]\n"
 238             "         -d master-backend-name [ ... master-backend args ... ]\n"
 239             "       jackdmp -d master-backend-name --help\n"
 240             "             to display options for each master backend\n\n");
 241
 242     if (full) {
 243         print_server_drivers(server, file);
 244         print_server_internals(server, file);
 245     }
 246 }
 247
 248 // Prototype to be found in libjackserver
 249 extern "C" void silent_jack_error_callback(const char *desc);
 250
 251 void print_version()
 252 {
 253     printf( "jackdmp version " VERSION " tmpdir "
 254             jack_server_dir " protocol %d" "\n",
 255             JACK_PROTOCOL_VERSION);
 256 }
 257
 258 int main(int argc, char** argv)
 259 {
 260     jackctl_server_t * server_ctl;
 261     const JSList * server_parameters;
 262     const char* server_name = JACK_DEFAULT_SERVER_NAME;
 263     jackctl_driver_t * master_driver_ctl;
 264     jackctl_driver_t * loopback_driver_ctl = NULL;
 265     int replace_registry = 0;
 266
 267     for(int a = 1; a < argc; ++a) {
 268         if( !strcmp(argv[a], "--version") || !strcmp(argv[a], "-V") ) {
 269             print_version();
 270             return 0;
 271         }
 272     }
 273     const char *options = "-d:X:I:P:uvshrRL:STFl:t:mn:p:C:"
 274         "a:"
 275 #ifdef __linux__
 276         "c:"
 277 #endif
 278         ;
 279
 280     struct option long_options[] = {
 281 #ifdef __linux__
 282                                        { "clock-source", 1, 0, 'c' },
 283 #endif
 284                                        { "internal-session-file", 1, 0, 'C' },
 285                                        { "loopback-driver", 1, 0, 'L' },
 286                                        { "audio-driver", 1, 0, 'd' },
 287                                        { "midi-driver", 1, 0, 'X' },
 288                                        { "internal-client", 1, 0, 'I' },
 289                                        { "verbose", 0, 0, 'v' },
 290                                        { "help", 0, 0, 'h' },
 291                                        { "port-max", 1, 0, 'p' },
 292                                        { "no-mlock", 0, 0, 'm' },
 293                                        { "name", 1, 0, 'n' },
 294                                        { "unlock", 0, 0, 'u' },
 295                                        { "realtime", 0, 0, 'R' },
 296                                        { "no-realtime", 0, 0, 'r' },
 297                                        { "replace-registry", 0, &replace_registry, 0 },
 298                                        { "loopback", 0, 0, 'L' },
 299                                        { "realtime-priority", 1, 0, 'P' },
 300                                        { "timeout", 1, 0, 't' },
 301                                        { "temporary", 0, 0, 'T' },
 302                                        { "silent", 0, 0, 's' },
 303                                        { "sync", 0, 0, 'S' },
 304                                        { "autoconnect", 1, 0, 'a' },
 305                                        { 0, 0, 0, 0 }
 306                                    };
 307
 308     int i,opt = 0;
 309     int option_index = 0;
 310     char* internal_session_file = NULL;
 311     char* master_driver_name = NULL;
 312     char** master_driver_args = NULL;
 313     int master_driver_nargs = 1;
 314     int loopback = 0;
 315     jackctl_sigmask_t * sigmask;
 316     jackctl_parameter_t* param;
 317     union jackctl_parameter_value value;
 318
 319     std::list<char*> internals_list;
 320     std::list<char*> slaves_list;
 321     std::list<char*>::iterator it;
 322
 323     // Assume that we fail.
 324     int return_value = -1;
 325     bool notify_sent = false;
 326
 327     copyright(stdout);
 328 #if defined(JACK_DBUS) && defined(__linux__)
 329     if (getenv("JACK_NO_AUDIO_RESERVATION"))
 330         server_ctl = jackctl_server_create2(NULL, NULL, NULL);
 331     else
 332         server_ctl = jackctl_server_create2(audio_acquire, audio_release, audio_reserve_loop);
 333 #else
 334     server_ctl = jackctl_server_create2(NULL, NULL, NULL);
 335 #endif
 336     if (server_ctl == NULL) {
 337         fprintf(stderr, "Failed to create server object\n");
 338         return -1;
 339     }
 340
 341     server_parameters = jackctl_server_get_parameters(server_ctl);
 342
 343     opterr = 0;
 344     while (!master_driver_name &&
 345             (opt = getopt_long(argc, argv, options,
 346                                long_options, &option_index)) != EOF) {
 347         switch (opt) {
 348
 349         #ifdef __linux__
 350             case 'c':
 351                 param = jackctl_get_parameter(server_parameters, "clock-source");
 352                 if (param != NULL) {
 353                     if (tolower (optarg[0]) == 'h') {
 354                         value.ui = JACK_TIMER_HPET;
 355                         jackctl_parameter_set_value(param, &value);
 356                     } else if (tolower (optarg[0]) == 'c') {
 357                         /* For backwards compatibility with scripts, allow
 358                          * the user to request the cycle clock on the
 359                          * command line, but use the system clock instead
 360                          */
 361                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
 362                         jackctl_parameter_set_value(param, &value);
 363                     } else if (tolower (optarg[0]) == 's') {
 364                         value.ui = JACK_TIMER_SYSTEM_CLOCK;
 365                         jackctl_parameter_set_value(param, &value);
 366                     } else {
 367                         usage(stdout, server_ctl);
 368                         goto destroy_server;
 369                     }
 370                 }
 371                 break;
 372         #endif
 373
 374             case 'a':
 375                 param = jackctl_get_parameter(server_parameters, "self-connect-mode");
 376                 if (param != NULL) {
 377                     bool value_valid = false;
 378                     for (uint32_t k=0; k<jackctl_parameter_get_enum_constraints_count( param ); k++ ) {
 379                         value = jackctl_parameter_get_enum_constraint_value( param, k );
 380                         if( value.c == optarg[0] )
 381                             value_valid = true;
 382                     }
 383
 384                     if( value_valid ) {
 385                         value.c = optarg[0];
 386                         jackctl_parameter_set_value(param, &value);
 387                     } else {
 388                         usage(stdout, server_ctl);
 389                         goto destroy_server;
 390                     }
 391                 }
 392                 break;
 393
 394             case 'd':
 395                 master_driver_name = optarg;
 396                 break;
 397
 398             case 'L':
 399                 loopback = atoi(optarg);
 400                 break;
 401
 402             case 'X':
 403                 slaves_list.push_back(optarg);
 404                 break;
 405
 406             case 'I':
 407                 internals_list.push_back(optarg);
 408                 break;
 409
 410             case 'p':
 411                 param = jackctl_get_parameter(server_parameters, "port-max");
 412                 if (param != NULL) {
 413                     value.ui = atoi(optarg);
 414                     jackctl_parameter_set_value(param, &value);
 415                 }
 416                 break;
 417
 418             case 'm':
 419                 break;
 420
 421             case 'u':
 422                 break;
 423
 424             case 'v':
 425                 param = jackctl_get_parameter(server_parameters, "verbose");
 426                 if (param != NULL) {
 427                     value.b = true;
 428                     jackctl_parameter_set_value(param, &value);
 429                 }
 430                 break;
 431
 432             case 's':
 433                 jack_set_error_function(silent_jack_error_callback);
 434                 break;
 435
 436             case 'S':
 437                 param = jackctl_get_parameter(server_parameters, "sync");
 438                 if (param != NULL) {
 439                     value.b = true;
 440                     jackctl_parameter_set_value(param, &value);
 441                 }
 442                 break;
 443
 444             case 'n':
 445                 server_name = optarg;
 446                 param = jackctl_get_parameter(server_parameters, "name");
 447                 if (param != NULL) {
 448                     strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
 449                     jackctl_parameter_set_value(param, &value);
 450                 }
 451                 break;
 452
 453             case 'C':
 454                 internal_session_file = optarg;
 455                 break;
 456
 457             case 'P':
 458                 param = jackctl_get_parameter(server_parameters, "realtime-priority");
 459                 if (param != NULL) {
 460                     value.i = atoi(optarg);
 461                     jackctl_parameter_set_value(param, &value);
 462                 }
 463                 break;
 464
 465             case 'r':
 466                 param = jackctl_get_parameter(server_parameters, "realtime");
 467                 if (param != NULL) {
 468                     value.b = false;
 469                     jackctl_parameter_set_value(param, &value);
 470                 }
 471                 break;
 472
 473             case 'R':
 474                 param = jackctl_get_parameter(server_parameters, "realtime");
 475                 if (param != NULL) {
 476                     value.b = true;
 477                     jackctl_parameter_set_value(param, &value);
 478                 }
 479                 break;
 480
 481             case 'T':
 482                 param = jackctl_get_parameter(server_parameters, "temporary");
 483                 if (param != NULL) {
 484                     value.b = true;
 485                     jackctl_parameter_set_value(param, &value);
 486                 }
 487                 break;
 488
 489             case 't':
 490                 param = jackctl_get_parameter(server_parameters, "client-timeout");
 491                 if (param != NULL) {
 492                     value.i = atoi(optarg);
 493                     jackctl_parameter_set_value(param, &value);
 494                 }
 495                 break;
 496
 497             case 'h':
 498                 usage(stdout, server_ctl);
 499                 return_value = 0;
 500                 goto destroy_server;
 501
 502             default:
 503                 fprintf(stderr, "unknown option character %c\n", optopt);
 504                 usage(stdout, server_ctl);
 505                 goto destroy_server;
 506         }
 507     }
 508
 509     // Long option with no letter so treated separately
 510     param = jackctl_get_parameter(server_parameters, "replace-registry");
 511     if (param != NULL) {
 512         value.b = replace_registry;
 513         jackctl_parameter_set_value(param, &value);
 514     }
 515
 516     if (!master_driver_name) {
 517         usage(stderr, server_ctl, false);
 518         goto destroy_server;
 519     }
 520
 521     // Master driver
 522     master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
 523     if (master_driver_ctl == NULL) {
 524         fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
 525         goto destroy_server;
 526     }
 527
 528     if (jackctl_driver_get_type(master_driver_ctl) != JackMaster) {
 529         fprintf(stderr, "Driver \"%s\" is not a master \n", master_driver_name);
 530         goto destroy_server;
 531     }
 532
 533     if (optind < argc) {
 534         master_driver_nargs = 1 + argc - optind;
 535     } else {
 536         master_driver_nargs = 1;
 537     }
 538
 539     if (master_driver_nargs == 0) {
 540         fprintf(stderr, "No driver specified ... hmm. JACK won't do"
 541                 " anything when run like this.\n");
 542         goto destroy_server;
 543     }
 544
 545     master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
 546     master_driver_args[0] = master_driver_name;
 547
 548     for (i = 1; i < master_driver_nargs; i++) {
 549         master_driver_args[i] = argv[optind++];
 550     }
 551
 552     if (jackctl_driver_params_parse(master_driver_ctl, master_driver_nargs, master_driver_args)) {
 553         goto destroy_server;
 554     }
 555
 556     // Setup signals
 557     sigmask = jackctl_setup_signals(0);
 558
 559     // Open server
 560     if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
 561         fprintf(stderr, "Failed to open server\n");
 562         goto destroy_server;
 563     }
 564
 565     // Slave drivers
 566     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
 567         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
 568         if (slave_driver_ctl == NULL) {
 569             fprintf(stderr, "Unknown driver \"%s\"\n", *it);
 570             goto close_server;
 571         }
 572         if (jackctl_driver_get_type(slave_driver_ctl) != JackSlave) {
 573             fprintf(stderr, "Driver \"%s\" is not a slave \n", *it);
 574             goto close_server;
 575         }
 576         if (!jackctl_server_add_slave(server_ctl, slave_driver_ctl)) {
 577             fprintf(stderr, "Driver \"%s\" cannot be loaded\n", *it);
 578             goto close_server;
 579         }
 580     }
 581
 582     // Loopback driver
 583     if (loopback > 0) {
 584         loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
 585
 586         if (loopback_driver_ctl != NULL) {
 587             const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
 588             param = jackctl_get_parameter(loopback_parameters, "channels");
 589             if (param != NULL) {
 590                 value.ui = loopback;
 591                 jackctl_parameter_set_value(param, &value);
 592             }
 593             if (!jackctl_server_add_slave(server_ctl, loopback_driver_ctl)) {
 594                 fprintf(stderr, "Driver \"loopback\" cannot be loaded\n");
 595                 goto close_server;
 596             }
 597         } else {
 598             fprintf(stderr, "Driver \"loopback\" not found\n");
 599             goto close_server;
 600         }
 601     }
 602
 603     // Start the server
 604     if (!jackctl_server_start(server_ctl)) {
 605         fprintf(stderr, "Failed to start server\n");
 606         goto close_server;
 607     }
 608
 609     // Internal clients
 610     for (it = internals_list.begin(); it != internals_list.end(); it++) {
 611         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
 612         if (internal_driver_ctl == NULL) {
 613             fprintf(stderr, "Unknown internal \"%s\"\n", *it);
 614             goto stop_server;
 615         }
 616         if (!jackctl_server_load_internal(server_ctl, internal_driver_ctl)) {
 617             fprintf(stderr, "Internal client \"%s\" cannot be loaded\n", *it);
 618             goto stop_server;
 619         }
 620     }
 621
 622     if (internal_session_file != NULL) {
 623         if (!jackctl_server_load_session_file(server_ctl, internal_session_file)) {
 624             fprintf(stderr, "Internal session file %s cannot be loaded!\n", internal_session_file);
 625             goto stop_server;
 626         }
 627     }
 628
 629     notify_server_start(server_name);
 630     notify_sent = true;
 631     return_value = 0;
 632
 633 #if HAVE_SYSTEMD
 634     sd_notify(0, "READY=1");
 635 #endif
 636
 637     // Waits for signal
 638 #ifdef __ANDROID__
 639     //reserve SIGUSR2 signal for switching master driver
 640     while(1) {
 641         int signal = jackctl_wait_signals_and_return(sigmask);
 642         if (signal == SIGUSR2) {
 643             jackctl_server_switch_master_dummy(server_ctl, master_driver_name);
 644         } else {
 645             break;
 646         }
 647     }
 648 #else
 649     jackctl_wait_signals(sigmask);
 650 #endif
 651
 652 #if HAVE_SYSTEMD
 653     sd_notify(0, "STOPPING=1");
 654 #endif
 655
 656  stop_server:
 657     if (!jackctl_server_stop(server_ctl)) {
 658         fprintf(stderr, "Cannot stop server...\n");
 659     }
 660
 661  close_server:
 662     if (loopback > 0 && loopback_driver_ctl) {
 663         jackctl_server_remove_slave(server_ctl, loopback_driver_ctl);
 664     }
 665     // Slave drivers
 666     for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
 667         jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
 668         if (slave_driver_ctl) {
 669             jackctl_server_remove_slave(server_ctl, slave_driver_ctl);
 670         }
 671     }
 672
 673     // Internal clients
 674     for (it = internals_list.begin(); it != internals_list.end(); it++) {
 675         jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
 676         if (internal_driver_ctl) {
 677             jackctl_server_unload_internal(server_ctl, internal_driver_ctl);
 678         }
 679     }
 680     jackctl_server_close(server_ctl);
 681
 682  destroy_server:
 683     jackctl_server_destroy(server_ctl);
 684     if (notify_sent) {
 685         notify_server_stop(server_name);
 686     }
 687     return return_value;
 688 }