common/JackRequest.h

   1 /*
   2 Copyright (C) 2001 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 Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #ifndef __JackRequest__
  22 #define __JackRequest__
  23
  24 #include "JackConstants.h"
  25 #include "JackError.h"
  26 #include "JackPlatformPlug.h"
  27 #include "JackChannel.h"
  28 #include "JackTime.h"
  29 #include "types.h"
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <list>
  34
  35 namespace Jack
  36 {
  37
  38 #define CheckRes(exp) { if ((exp) < 0) { jack_error("CheckRes error"); return -1; } }
  39 #define CheckSize() { CheckRes(trans->Read(&fSize, sizeof(int))); if (fSize != Size()) { jack_error("CheckSize error size = %d Size() = %d", fSize, Size()); return -1; } }
  40
  41 /*!
  42 \brief Session API constants.
  43 */
  44
  45 enum JackSessionReply {
  46
  47     kImmediateSessionReply = 1,
  48     kPendingSessionReply = 2
  49
  50 };
  51
  52 /*!
  53 \brief Request from client to server.
  54 */
  55
  56 struct JackRequest
  57 {
  58
  59     enum RequestType {
  60         kRegisterPort = 1,
  61         kUnRegisterPort = 2,
  62         kConnectPorts = 3,
  63         kDisconnectPorts = 4,
  64         kSetTimeBaseClient = 5,
  65         kActivateClient = 6,
  66         kDeactivateClient = 7,
  67         kDisconnectPort = 8,
  68         kSetClientCapabilities = 9,
  69         kGetPortConnections = 10,
  70         kGetPortNConnections = 11,
  71         kReleaseTimebase = 12,
  72         kSetTimebaseCallback = 13,
  73         kSetBufferSize = 20,
  74         kSetFreeWheel = 21,
  75         kClientCheck = 22,
  76         kClientOpen = 23,
  77         kClientClose = 24,
  78         kConnectNamePorts = 25,
  79         kDisconnectNamePorts = 26,
  80         kGetInternalClientName = 27,
  81         kInternalClientHandle = 28,
  82         kInternalClientLoad = 29,
  83         kInternalClientUnload = 30,
  84         kPortRename = 31,
  85         kNotification = 32,
  86         kSessionNotify = 33,
  87         kSessionReply  = 34,
  88         kGetClientByUUID = 35,
  89         kReserveClientName = 36,
  90         kGetUUIDByClient = 37,
  91         kClientHasSessionCallback = 38,
  92         kComputeTotalLatencies = 39,
  93         kPropertyChangeNotify = 40
  94     };
  95
  96     RequestType fType;
  97     int fSize;
  98
  99     JackRequest(): fType((RequestType)0), fSize(0)
 100     {}
 101
 102     JackRequest(RequestType type): fType(type), fSize(0)
 103     {}
 104
 105     virtual ~JackRequest()
 106     {}
 107
 108     virtual int Read(detail::JackChannelTransactionInterface* trans)
 109     {
 110         return trans->Read(&fType, sizeof(RequestType));
 111     }
 112
 113     virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
 114
 115     virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
 116     {
 117         fSize = size;
 118         CheckRes(trans->Write(&fType, sizeof(RequestType)));
 119         return trans->Write(&fSize, sizeof(int));
 120     }
 121
 122     virtual int Size() { return 0; }
 123
 124 };
 125
 126 /*!
 127 \brief Result from the server.
 128 */
 129
 130 struct JackResult
 131 {
 132
 133     int fResult;
 134
 135     JackResult(): fResult( -1)
 136     {}
 137     JackResult(int result): fResult(result)
 138     {}
 139     virtual ~JackResult()
 140     {}
 141
 142     virtual int Read(detail::JackChannelTransactionInterface* trans)
 143     {
 144         return trans->Read(&fResult, sizeof(int));
 145     }
 146
 147     virtual int Write(detail::JackChannelTransactionInterface* trans)
 148     {
 149         return trans->Write(&fResult, sizeof(int));
 150     }
 151
 152 };
 153
 154 /*!
 155 \brief CheckClient request.
 156 */
 157
 158 struct JackClientCheckRequest : public JackRequest
 159 {
 160
 161     char fName[JACK_CLIENT_NAME_SIZE+1];
 162     int fProtocol;
 163     int fOptions;
 164     int fOpen;
 165     jack_uuid_t fUUID;
 166
 167     JackClientCheckRequest() : fProtocol(0), fOptions(0), fOpen(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
 168     {
 169         memset(fName, 0, sizeof(fName));
 170     }
 171     JackClientCheckRequest(const char* name, int protocol, int options, jack_uuid_t uuid, int open = false)
 172         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fOpen(open), fUUID(uuid)
 173     {
 174         memset(fName, 0, sizeof(fName));
 175         snprintf(fName, sizeof(fName), "%s", name);
 176     }
 177
 178     int Read(detail::JackChannelTransactionInterface* trans)
 179     {
 180         CheckSize();
 181         CheckRes(trans->Read(&fName, sizeof(fName)));
 182         CheckRes(trans->Read(&fProtocol, sizeof(int)));
 183         CheckRes(trans->Read(&fOptions, sizeof(int)));
 184         CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
 185         return trans->Read(&fOpen, sizeof(int));
 186     }
 187
 188     int Write(detail::JackChannelTransactionInterface* trans)
 189     {
 190         CheckRes(JackRequest::Write(trans, Size()));
 191         CheckRes(trans->Write(&fName, sizeof(fName)));
 192         CheckRes(trans->Write(&fProtocol, sizeof(int)));
 193         CheckRes(trans->Write(&fOptions, sizeof(int)));
 194         CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
 195         return trans->Write(&fOpen, sizeof(int));
 196     }
 197
 198     int Size() { return sizeof(fName) + 3 * sizeof(int) + sizeof(jack_uuid_t); }
 199
 200 };
 201
 202 /*!
 203 \brief CheckClient result.
 204 */
 205
 206 struct JackClientCheckResult : public JackResult
 207 {
 208
 209     char fName[JACK_CLIENT_NAME_SIZE+1];
 210     int fStatus;
 211
 212     JackClientCheckResult(): JackResult(), fStatus(0)
 213     {
 214         memset(fName, 0, sizeof(fName));
 215     }
 216     JackClientCheckResult(int32_t result, const char* name, int status)
 217             : JackResult(result), fStatus(status)
 218     {
 219         memset(fName, 0, sizeof(fName));
 220         snprintf(fName, sizeof(fName), "%s", name);
 221     }
 222
 223     int Read(detail::JackChannelTransactionInterface* trans)
 224     {
 225         CheckRes(JackResult::Read(trans));
 226         CheckRes(trans->Read(&fName, sizeof(fName)));
 227         CheckRes(trans->Read(&fStatus, sizeof(int)));
 228         return 0;
 229     }
 230
 231     int Write(detail::JackChannelTransactionInterface* trans)
 232     {
 233         CheckRes(JackResult::Write(trans));
 234         CheckRes(trans->Write(&fName, sizeof(fName)));
 235         CheckRes(trans->Write(&fStatus, sizeof(int)));
 236         return 0;
 237     }
 238
 239 };
 240
 241 /*!
 242 \brief NewClient request.
 243 */
 244
 245 struct JackClientOpenRequest : public JackRequest
 246 {
 247
 248     int fPID;
 249     jack_uuid_t fUUID;
 250     char fName[JACK_CLIENT_NAME_SIZE+1];
 251
 252     JackClientOpenRequest() : fPID(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
 253     {
 254         memset(fName, 0, sizeof(fName));
 255     }
 256     JackClientOpenRequest(const char* name, int pid, jack_uuid_t uuid): JackRequest(JackRequest::kClientOpen)
 257     {
 258         memset(fName, 0, sizeof(fName));
 259         snprintf(fName, sizeof(fName), "%s", name);
 260         fPID = pid;
 261         fUUID = uuid;
 262     }
 263
 264     int Read(detail::JackChannelTransactionInterface* trans)
 265     {
 266         CheckSize();
 267         CheckRes(trans->Read(&fPID, sizeof(int)));
 268         CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
 269         return trans->Read(&fName, sizeof(fName));
 270     }
 271
 272     int Write(detail::JackChannelTransactionInterface* trans)
 273     {
 274         CheckRes(JackRequest::Write(trans, Size()));
 275         CheckRes(trans->Write(&fPID, sizeof(int)));
 276         CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
 277         return trans->Write(&fName, sizeof(fName));
 278     }
 279
 280     int Size() { return sizeof(int) + sizeof(jack_uuid_t) + sizeof(fName); }
 281
 282 };
 283
 284 /*!
 285 \brief NewClient result.
 286 */
 287
 288 struct JackClientOpenResult : public JackResult
 289 {
 290
 291     int fSharedEngine;
 292     int fSharedClient;
 293     int fSharedGraph;
 294
 295     JackClientOpenResult()
 296             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
 297     {}
 298     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
 299             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
 300     {}
 301
 302     int Read(detail::JackChannelTransactionInterface* trans)
 303     {
 304         CheckRes(JackResult::Read(trans));
 305         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
 306         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
 307         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
 308         return 0;
 309     }
 310
 311     int Write(detail::JackChannelTransactionInterface* trans)
 312     {
 313         CheckRes(JackResult::Write(trans));
 314         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
 315         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
 316         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
 317         return 0;
 318     }
 319
 320 };
 321
 322 /*!
 323 \brief CloseClient request.
 324 */
 325
 326 struct JackClientCloseRequest : public JackRequest
 327 {
 328
 329     int fRefNum;
 330
 331     JackClientCloseRequest() : fRefNum(0)
 332     {}
 333     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
 334     {}
 335
 336     int Read(detail::JackChannelTransactionInterface* trans)
 337     {
 338         CheckSize();
 339         return trans->Read(&fRefNum, sizeof(int));
 340     }
 341
 342     int Write(detail::JackChannelTransactionInterface* trans)
 343     {
 344         CheckRes(JackRequest::Write(trans, Size()));
 345         return trans->Write(&fRefNum, sizeof(int));
 346     }
 347
 348     int Size() { return sizeof(int); }
 349 };
 350
 351 /*!
 352 \brief Activate request.
 353 */
 354
 355 struct JackActivateRequest : public JackRequest
 356 {
 357
 358     int fRefNum;
 359     int fIsRealTime;
 360
 361     JackActivateRequest() : fRefNum(0), fIsRealTime(0)
 362     {}
 363     JackActivateRequest(int refnum, int is_real_time)
 364         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
 365     {}
 366
 367     int Read(detail::JackChannelTransactionInterface* trans)
 368     {
 369         CheckSize();
 370         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 371         return trans->Read(&fIsRealTime, sizeof(int));
 372     }
 373
 374     int Write(detail::JackChannelTransactionInterface* trans)
 375     {
 376         CheckRes(JackRequest::Write(trans, Size()));
 377         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 378         return trans->Write(&fIsRealTime, sizeof(int));
 379     }
 380
 381     int Size() { return 2 * sizeof(int); }
 382 };
 383
 384 /*!
 385 \brief Deactivate request.
 386 */
 387
 388 struct JackDeactivateRequest : public JackRequest
 389 {
 390
 391     int fRefNum;
 392
 393     JackDeactivateRequest() : fRefNum(0)
 394     {}
 395     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
 396     {}
 397
 398     int Read(detail::JackChannelTransactionInterface* trans)
 399     {
 400         CheckSize();
 401         return trans->Read(&fRefNum, sizeof(int));
 402     }
 403
 404     int Write(detail::JackChannelTransactionInterface* trans)
 405     {
 406         CheckRes(JackRequest::Write(trans, Size()));
 407         return trans->Write(&fRefNum, sizeof(int));
 408     }
 409
 410     int Size() { return sizeof(int); }
 411 };
 412
 413 /*!
 414 \brief PortRegister request.
 415 */
 416
 417 struct JackPortRegisterRequest : public JackRequest
 418 {
 419
 420     int fRefNum;
 421     char fName[JACK_PORT_NAME_SIZE + 1];   // port short name
 422     char fPortType[JACK_PORT_TYPE_SIZE + 1];
 423     unsigned int fFlags;
 424     unsigned int fBufferSize;
 425
 426     JackPortRegisterRequest() : fRefNum(0), fFlags(0), fBufferSize(0)
 427     {
 428         memset(fName, 0, sizeof(fName));
 429         memset(fPortType, 0, sizeof(fPortType));
 430     }
 431     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
 432             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
 433     {
 434         memset(fName, 0, sizeof(fName));
 435         memset(fPortType, 0, sizeof(fPortType));
 436         strncpy(fName, name, sizeof(fName)-1);
 437         strncpy(fPortType, port_type, sizeof(fPortType)-1);
 438     }
 439
 440     int Read(detail::JackChannelTransactionInterface* trans)
 441     {
 442         CheckSize();
 443         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 444         CheckRes(trans->Read(&fName, sizeof(fName)));
 445         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
 446         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
 447         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
 448         return 0;
 449     }
 450
 451     int Write(detail::JackChannelTransactionInterface* trans)
 452     {
 453         CheckRes(JackRequest::Write(trans, Size()));
 454         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 455         CheckRes(trans->Write(&fName, sizeof(fName)));
 456         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
 457         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
 458         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
 459         return 0;
 460     }
 461
 462     int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
 463
 464 };
 465
 466 /*!
 467 \brief PortRegister result.
 468 */
 469
 470 struct JackPortRegisterResult : public JackResult
 471 {
 472
 473     jack_port_id_t fPortIndex;
 474
 475     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
 476     {}
 477
 478     int Read(detail::JackChannelTransactionInterface* trans)
 479     {
 480         CheckRes(JackResult::Read(trans));
 481         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
 482     }
 483
 484     int Write(detail::JackChannelTransactionInterface* trans)
 485     {
 486         CheckRes(JackResult::Write(trans));
 487         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
 488     }
 489
 490 };
 491
 492 /*!
 493 \brief PortUnregister request.
 494 */
 495
 496 struct JackPortUnRegisterRequest : public JackRequest
 497 {
 498
 499     int fRefNum;
 500     jack_port_id_t fPortIndex;
 501
 502     JackPortUnRegisterRequest() : fRefNum(0), fPortIndex(0)
 503     {}
 504     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
 505         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
 506     {}
 507
 508     int Read(detail::JackChannelTransactionInterface* trans)
 509     {
 510         CheckSize();
 511         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 512         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
 513         return 0;
 514     }
 515
 516     int Write(detail::JackChannelTransactionInterface* trans)
 517     {
 518         CheckRes(JackRequest::Write(trans, Size()));
 519         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 520         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
 521         return 0;
 522     }
 523
 524     int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
 525 };
 526
 527 /*!
 528 \brief PortConnectName request.
 529 */
 530
 531 struct JackPortConnectNameRequest : public JackRequest
 532 {
 533
 534     int fRefNum;
 535     char fSrc[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 536     char fDst[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 537
 538     JackPortConnectNameRequest() : fRefNum(0)
 539     {
 540         memset(fSrc, 0, sizeof(fSrc));
 541         memset(fDst, 0, sizeof(fDst));
 542     }
 543     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
 544         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
 545     {
 546         memset(fSrc, 0, sizeof(fSrc));
 547         memset(fDst, 0, sizeof(fDst));
 548         strncpy(fSrc, src_name, sizeof(fSrc)-1);
 549         strncpy(fDst, dst_name, sizeof(fDst)-1);
 550     }
 551
 552     int Read(detail::JackChannelTransactionInterface* trans)
 553     {
 554         CheckSize();
 555         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 556         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
 557         CheckRes(trans->Read(&fDst, sizeof(fDst)));
 558         return 0;
 559     }
 560
 561     int Write(detail::JackChannelTransactionInterface* trans)
 562     {
 563         CheckRes(JackRequest::Write(trans, Size()));
 564         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 565         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
 566         CheckRes(trans->Write(&fDst, sizeof(fDst)));
 567         return 0;
 568     }
 569
 570     int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
 571
 572 };
 573
 574 /*!
 575 \brief PortDisconnectName request.
 576 */
 577
 578 struct JackPortDisconnectNameRequest : public JackRequest
 579 {
 580
 581     int fRefNum;
 582     char fSrc[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 583     char fDst[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 584
 585     JackPortDisconnectNameRequest() : fRefNum(0)
 586     {
 587         memset(fSrc, 0, sizeof(fSrc));
 588         memset(fDst, 0, sizeof(fDst));
 589     }
 590     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
 591         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
 592     {
 593         memset(fSrc, 0, sizeof(fSrc));
 594         memset(fDst, 0, sizeof(fDst));
 595         strncpy(fSrc, src_name, sizeof(fSrc)-1);
 596         strncpy(fDst, dst_name, sizeof(fDst)-1);
 597     }
 598
 599     int Read(detail::JackChannelTransactionInterface* trans)
 600     {
 601         CheckSize();
 602         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 603         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
 604         CheckRes(trans->Read(&fDst, sizeof(fDst)));
 605         return 0;
 606     }
 607
 608     int Write(detail::JackChannelTransactionInterface* trans)
 609     {
 610         CheckRes(JackRequest::Write(trans, Size()));
 611         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 612         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
 613         CheckRes(trans->Write(&fDst, sizeof(fDst)));
 614         return 0;
 615     }
 616
 617     int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
 618
 619 };
 620
 621 /*!
 622 \brief PortConnect request.
 623 */
 624
 625 struct JackPortConnectRequest : public JackRequest
 626 {
 627
 628     int fRefNum;
 629     jack_port_id_t fSrc;
 630     jack_port_id_t fDst;
 631
 632     JackPortConnectRequest() : fRefNum(0), fSrc(0), fDst(0)
 633     {}
 634     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
 635         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
 636     {}
 637
 638     int Read(detail::JackChannelTransactionInterface* trans)
 639     {
 640         CheckSize();
 641         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 642         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
 643         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
 644         return 0;
 645     }
 646
 647     int Write(detail::JackChannelTransactionInterface* trans)
 648     {
 649         CheckRes(JackRequest::Write(trans, Size()));
 650         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 651         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
 652         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
 653         return 0;
 654     }
 655
 656     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
 657 };
 658
 659 /*!
 660 \brief PortDisconnect request.
 661 */
 662
 663 struct JackPortDisconnectRequest : public JackRequest
 664 {
 665
 666     int fRefNum;
 667     jack_port_id_t fSrc;
 668     jack_port_id_t fDst;
 669
 670     JackPortDisconnectRequest() : fRefNum(0), fSrc(0), fDst(0)
 671     {}
 672     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
 673         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
 674     {}
 675
 676     int Read(detail::JackChannelTransactionInterface* trans)
 677     {
 678         CheckSize();
 679         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 680         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
 681         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
 682         return 0;
 683     }
 684
 685     int Write(detail::JackChannelTransactionInterface* trans)
 686     {
 687         CheckRes(JackRequest::Write(trans, Size()));
 688         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 689         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
 690         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
 691         return 0;
 692     }
 693
 694     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
 695 };
 696
 697 /*!
 698 \brief PortRename request.
 699 */
 700
 701 struct JackPortRenameRequest : public JackRequest
 702 {
 703
 704     int fRefNum;
 705     jack_port_id_t fPort;
 706     char fName[JACK_PORT_NAME_SIZE + 1];   // port short name
 707
 708     JackPortRenameRequest() : fRefNum(0), fPort(0)
 709     {
 710         memset(fName, 0, sizeof(fName));
 711     }
 712     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
 713         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
 714     {
 715         memset(fName, 0, sizeof(fName));
 716         strncpy(fName, name, sizeof(fName)-1);
 717     }
 718
 719     int Read(detail::JackChannelTransactionInterface* trans)
 720     {
 721         CheckSize();
 722         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 723         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
 724         CheckRes(trans->Read(&fName, sizeof(fName)));
 725         return 0;
 726     }
 727
 728     int Write(detail::JackChannelTransactionInterface* trans)
 729     {
 730         CheckRes(JackRequest::Write(trans, Size()));
 731         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 732         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
 733         CheckRes(trans->Write(&fName, sizeof(fName)));
 734         return 0;
 735     }
 736
 737     int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
 738
 739 };
 740
 741 /*!
 742 \brief SetBufferSize request.
 743 */
 744
 745 struct JackSetBufferSizeRequest : public JackRequest
 746 {
 747
 748     jack_nframes_t fBufferSize;
 749
 750     JackSetBufferSizeRequest() : fBufferSize(0)
 751     {}
 752     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
 753         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
 754     {}
 755
 756     int Read(detail::JackChannelTransactionInterface* trans)
 757     {
 758         CheckSize();
 759         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
 760     }
 761
 762     int Write(detail::JackChannelTransactionInterface* trans)
 763     {
 764         CheckRes(JackRequest::Write(trans, Size()));
 765         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
 766     }
 767
 768     int Size() { return sizeof(jack_nframes_t); }
 769 };
 770
 771 /*!
 772 \brief SetFreeWheel request.
 773 */
 774
 775 struct JackSetFreeWheelRequest : public JackRequest
 776 {
 777
 778     int fOnOff;
 779
 780     JackSetFreeWheelRequest() : fOnOff(0)
 781     {}
 782     JackSetFreeWheelRequest(int onoff)
 783         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
 784     {}
 785
 786     int Read(detail::JackChannelTransactionInterface* trans)
 787     {
 788         CheckSize();
 789         return trans->Read(&fOnOff, sizeof(int));
 790     }
 791
 792     int Write(detail::JackChannelTransactionInterface* trans)
 793     {
 794         CheckRes(JackRequest::Write(trans, Size()));
 795         return trans->Write(&fOnOff, sizeof(int));
 796     }
 797
 798     int Size() { return sizeof(int); }
 799
 800 };
 801
 802 /*!
 803 \brief ComputeTotalLatencies request.
 804 */
 805
 806 struct JackComputeTotalLatenciesRequest : public JackRequest
 807 {
 808
 809     JackComputeTotalLatenciesRequest()
 810         : JackRequest(JackRequest::kComputeTotalLatencies)
 811     {}
 812
 813     int Read(detail::JackChannelTransactionInterface* trans)
 814     {
 815         CheckSize();
 816         return 0;
 817     }
 818
 819     int Write(detail::JackChannelTransactionInterface* trans)
 820     {
 821         CheckRes(JackRequest::Write(trans, Size()));
 822         return 0;
 823     }
 824
 825     int Size() { return 0; }
 826 };
 827
 828 /*!
 829 \brief ReleaseTimebase request.
 830 */
 831
 832 struct JackReleaseTimebaseRequest : public JackRequest
 833 {
 834
 835     int fRefNum;
 836
 837     JackReleaseTimebaseRequest() : fRefNum(0)
 838     {}
 839     JackReleaseTimebaseRequest(int refnum)
 840         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
 841     {}
 842
 843     int Read(detail::JackChannelTransactionInterface* trans)
 844     {
 845         CheckSize();
 846         return trans->Read(&fRefNum, sizeof(int));
 847     }
 848
 849     int Write(detail::JackChannelTransactionInterface* trans)
 850     {
 851         CheckRes(JackRequest::Write(trans, Size()));
 852         return trans->Write(&fRefNum, sizeof(int));
 853     }
 854
 855     int Size() { return sizeof(int); }
 856
 857 };
 858
 859 /*!
 860 \brief SetTimebaseCallback request.
 861 */
 862
 863 struct JackSetTimebaseCallbackRequest : public JackRequest
 864 {
 865
 866     int fRefNum;
 867     int fConditionnal;
 868
 869     JackSetTimebaseCallbackRequest() : fRefNum(0), fConditionnal(0)
 870     {}
 871     JackSetTimebaseCallbackRequest(int refnum, int conditional)
 872         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
 873     {}
 874
 875     int Read(detail::JackChannelTransactionInterface* trans)
 876     {
 877         CheckSize();
 878         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 879         return trans->Read(&fConditionnal, sizeof(int));
 880     }
 881
 882     int Write(detail::JackChannelTransactionInterface* trans)
 883     {
 884         CheckRes(JackRequest::Write(trans, Size()));
 885         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 886         return trans->Write(&fConditionnal, sizeof(int));
 887     }
 888
 889     int Size() { return sizeof(int) + sizeof(int); }
 890 };
 891
 892 /*!
 893 \brief GetInternalClientName request.
 894 */
 895
 896 struct JackGetInternalClientNameRequest : public JackRequest
 897 {
 898
 899     int fRefNum;
 900     int fIntRefNum;
 901
 902     JackGetInternalClientNameRequest() : fRefNum(0), fIntRefNum(0)
 903     {}
 904     JackGetInternalClientNameRequest(int refnum, int int_ref)
 905             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
 906     {}
 907
 908     int Read(detail::JackChannelTransactionInterface* trans)
 909     {
 910         CheckSize();
 911         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 912         return trans->Read(&fIntRefNum, sizeof(int));
 913     }
 914
 915     int Write(detail::JackChannelTransactionInterface* trans)
 916     {
 917         CheckRes(JackRequest::Write(trans, Size()));
 918         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 919         return trans->Write(&fIntRefNum, sizeof(int));
 920     }
 921
 922     int Size() { return sizeof(int) + sizeof(int); }
 923 };
 924
 925 /*!
 926 \brief GetInternalClient result.
 927 */
 928
 929 struct JackGetInternalClientNameResult : public JackResult
 930 {
 931
 932     char fName[JACK_CLIENT_NAME_SIZE+1];
 933
 934     JackGetInternalClientNameResult(): JackResult()
 935     {
 936         memset(fName, 0, sizeof(fName));
 937     }
 938     JackGetInternalClientNameResult(int32_t result, const char* name)
 939             : JackResult(result)
 940     {
 941         memset(fName, 0, sizeof(fName));
 942         snprintf(fName, sizeof(fName), "%s", name);
 943     }
 944
 945     int Read(detail::JackChannelTransactionInterface* trans)
 946     {
 947         CheckRes(JackResult::Read(trans));
 948         CheckRes(trans->Read(&fName, sizeof(fName)));
 949         return 0;
 950     }
 951
 952     int Write(detail::JackChannelTransactionInterface* trans)
 953     {
 954         CheckRes(JackResult::Write(trans));
 955         CheckRes(trans->Write(&fName, sizeof(fName)));
 956         return 0;
 957     }
 958
 959     int Size() { return sizeof(fName); }
 960 };
 961
 962 /*!
 963 \brief InternalClientHandle request.
 964 */
 965
 966 struct JackInternalClientHandleRequest : public JackRequest
 967 {
 968
 969     int fRefNum;
 970     char fName[JACK_CLIENT_NAME_SIZE+1];
 971
 972     JackInternalClientHandleRequest() : fRefNum(0)
 973     {
 974         memset(fName, 0, sizeof(fName));
 975     }
 976     JackInternalClientHandleRequest(int refnum, const char* client_name)
 977             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
 978     {
 979         memset(fName, 0, sizeof(fName));
 980         snprintf(fName, sizeof(fName), "%s", client_name);
 981     }
 982
 983     int Read(detail::JackChannelTransactionInterface* trans)
 984     {
 985         CheckSize();
 986         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 987         return trans->Read(&fName, sizeof(fName));
 988     }
 989
 990     int Write(detail::JackChannelTransactionInterface* trans)
 991     {
 992         CheckRes(JackRequest::Write(trans, Size()));
 993         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 994         return trans->Write(&fName, sizeof(fName));
 995     }
 996
 997     int Size() { return sizeof(int) + sizeof(fName); }
 998 };
 999
1000 /*!
1001 \brief InternalClientHandle result.
1002 */
1003
1004 struct JackInternalClientHandleResult : public JackResult
1005 {
1006
1007     int fStatus;
1008     int fIntRefNum;
1009
1010     JackInternalClientHandleResult(): JackResult(), fStatus(0), fIntRefNum(0)
1011     {}
1012     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
1013             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1014     {}
1015
1016     int Read(detail::JackChannelTransactionInterface* trans)
1017     {
1018         CheckRes(JackResult::Read(trans));
1019         CheckRes(trans->Read(&fStatus, sizeof(int)));
1020         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1021         return 0;
1022     }
1023
1024     int Write(detail::JackChannelTransactionInterface* trans)
1025     {
1026         CheckRes(JackResult::Write(trans));
1027         CheckRes(trans->Write(&fStatus, sizeof(int)));
1028         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1029         return 0;
1030     }
1031
1032     int Size() { return sizeof(int) + sizeof(int); }
1033 };
1034
1035 /*!
1036 \brief InternalClientLoad request.
1037 */
1038
1039 struct JackInternalClientLoadRequest : public JackRequest
1040 {
1041
1042 #ifndef MAX_PATH
1043 #define MAX_PATH 256
1044 #endif
1045
1046     int fRefNum;
1047     char fName[JACK_CLIENT_NAME_SIZE+1];
1048     char fDllName[MAX_PATH+1];
1049     char fLoadInitName[JACK_LOAD_INIT_LIMIT+1];
1050     int fOptions;
1051     jack_uuid_t fUUID;
1052
1053     JackInternalClientLoadRequest() : fRefNum(0), fOptions(0), fUUID(JACK_UUID_EMPTY_INITIALIZER)
1054     {
1055         memset(fName, 0, sizeof(fName));
1056         memset(fDllName, 0, sizeof(fDllName));
1057         memset(fLoadInitName, 0, sizeof(fLoadInitName));
1058     }
1059     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, jack_uuid_t uuid )
1060             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
1061     {
1062         memset(fName, 0, sizeof(fName));
1063         memset(fDllName, 0, sizeof(fDllName));
1064         memset(fLoadInitName, 0, sizeof(fLoadInitName));
1065         strncpy(fName, client_name, sizeof(fName)-1);
1066         if (so_name) {
1067             strncpy(fDllName, so_name, sizeof(fDllName)-1);
1068         }
1069         if (objet_data) {
1070             strncpy(fLoadInitName, objet_data, sizeof(fLoadInitName)-1);
1071         }
1072     }
1073
1074     int Read(detail::JackChannelTransactionInterface* trans)
1075     {
1076         CheckSize();
1077         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1078         CheckRes(trans->Read(&fName, sizeof(fName)));
1079         CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
1080         CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
1081         CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
1082         return trans->Read(&fOptions, sizeof(int));
1083     }
1084
1085     int Write(detail::JackChannelTransactionInterface* trans)
1086     {
1087         CheckRes(JackRequest::Write(trans, Size()));
1088         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1089         CheckRes(trans->Write(&fName, sizeof(fName)));
1090         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
1091         CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
1092         CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
1093         return trans->Write(&fOptions, sizeof(int));
1094     }
1095
1096     int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + sizeof(int) + sizeof(jack_uuid_t); }
1097 };
1098
1099 /*!
1100 \brief InternalClientLoad result.
1101 */
1102
1103 struct JackInternalClientLoadResult : public JackResult
1104 {
1105
1106     int fStatus;
1107     int fIntRefNum;
1108
1109     JackInternalClientLoadResult(): JackResult(), fStatus(0), fIntRefNum(0)
1110     {}
1111     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
1112             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
1113     {}
1114
1115     int Read(detail::JackChannelTransactionInterface* trans)
1116     {
1117         CheckRes(JackResult::Read(trans));
1118         CheckRes(trans->Read(&fStatus, sizeof(int)));
1119         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
1120         return 0;
1121     }
1122
1123     int Write(detail::JackChannelTransactionInterface* trans)
1124     {
1125         CheckRes(JackResult::Write(trans));
1126         CheckRes(trans->Write(&fStatus, sizeof(int)));
1127         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
1128         return 0;
1129     }
1130
1131     int Size() { return sizeof(int) + sizeof(int); }
1132 };
1133
1134 /*!
1135 \brief InternalClientUnload request.
1136 */
1137
1138 struct JackInternalClientUnloadRequest : public JackRequest
1139 {
1140
1141     int fRefNum;
1142     int fIntRefNum;
1143
1144     JackInternalClientUnloadRequest() : fRefNum(0), fIntRefNum(0)
1145     {}
1146     JackInternalClientUnloadRequest(int refnum, int int_ref)
1147             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
1148     {}
1149
1150     int Read(detail::JackChannelTransactionInterface* trans)
1151     {
1152         CheckSize();
1153         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1154         return trans->Read(&fIntRefNum, sizeof(int));
1155     }
1156
1157     int Write(detail::JackChannelTransactionInterface* trans)
1158     {
1159         CheckRes(JackRequest::Write(trans, Size()));
1160         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1161         return trans->Write(&fIntRefNum, sizeof(int));
1162     }
1163
1164     int Size() { return sizeof(int) + sizeof(int); }
1165 };
1166
1167 /*!
1168 \brief InternalClientLoad result.
1169 */
1170
1171 struct JackInternalClientUnloadResult : public JackResult
1172 {
1173
1174     int fStatus;
1175
1176     JackInternalClientUnloadResult(): JackResult(), fStatus(0)
1177     {}
1178     JackInternalClientUnloadResult(int32_t result, int status)
1179             : JackResult(result), fStatus(status)
1180     {}
1181
1182     int Read(detail::JackChannelTransactionInterface* trans)
1183     {
1184         CheckRes(JackResult::Read(trans));
1185         CheckRes(trans->Read(&fStatus, sizeof(int)));
1186         return 0;
1187     }
1188
1189     int Write(detail::JackChannelTransactionInterface* trans)
1190     {
1191         CheckRes(JackResult::Write(trans));
1192         CheckRes(trans->Write(&fStatus, sizeof(int)));
1193         return 0;
1194     }
1195
1196     int Size() { return sizeof(int); }
1197 };
1198
1199 /*!
1200 \brief ClientNotification request.
1201 */
1202
1203 struct JackClientNotificationRequest : public JackRequest
1204 {
1205
1206     int fRefNum;
1207     int fNotify;
1208     int fValue;
1209
1210     JackClientNotificationRequest() : fRefNum(0), fNotify(0), fValue(0)
1211     {}
1212     JackClientNotificationRequest(int refnum, int notify, int value)
1213             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1214     {}
1215
1216     int Read(detail::JackChannelTransactionInterface* trans)
1217     {
1218         CheckSize();
1219         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1220         CheckRes(trans->Read(&fNotify, sizeof(int)));
1221         CheckRes(trans->Read(&fValue, sizeof(int)));
1222         return 0;
1223     }
1224
1225     int Write(detail::JackChannelTransactionInterface* trans)
1226     {
1227         CheckRes(JackRequest::Write(trans, Size()));
1228         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1229         CheckRes(trans->Write(&fNotify, sizeof(int)));
1230         CheckRes(trans->Write(&fValue, sizeof(int)));
1231         return 0;
1232     }
1233
1234     int Size() { return 3 * sizeof(int); }
1235
1236 };
1237
1238 struct JackSessionCommand
1239 {
1240     char fUUID[JACK_UUID_STRING_SIZE];
1241     char fClientName[JACK_CLIENT_NAME_SIZE+1];
1242     char fCommand[JACK_SESSION_COMMAND_SIZE+1];
1243     jack_session_flags_t fFlags;
1244
1245     JackSessionCommand() : fFlags(JackSessionSaveError)
1246     {
1247         memset(fUUID, 0, sizeof(fUUID));
1248         memset(fClientName, 0, sizeof(fClientName));
1249         memset(fCommand, 0, sizeof(fCommand));
1250     }
1251     JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
1252     {
1253         memset(fUUID, 0, sizeof(fUUID));
1254         memset(fClientName, 0, sizeof(fClientName));
1255         memset(fCommand, 0, sizeof(fCommand));
1256         strncpy(fUUID, uuid, sizeof(fUUID)-1);
1257         strncpy(fClientName, clientname, sizeof(fClientName)-1);
1258         strncpy(fCommand, command, sizeof(fCommand)-1);
1259         fFlags = flags;
1260     }
1261 };
1262
1263 struct JackSessionNotifyResult : public JackResult
1264 {
1265
1266     std::list<JackSessionCommand> fCommandList;
1267     bool fDone;
1268
1269     JackSessionNotifyResult(): JackResult(), fDone(false)
1270     {}
1271     JackSessionNotifyResult(int32_t result)
1272             : JackResult(result), fDone(false)
1273     {}
1274
1275     int Read(detail::JackChannelTransactionInterface* trans)
1276     {
1277         if (trans == NULL)
1278         {
1279             return 0;
1280         }
1281
1282         CheckRes(JackResult::Read(trans));
1283         while (true) {
1284             JackSessionCommand buffer;
1285
1286             CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
1287             if (buffer.fUUID[0] == '\0')
1288                 break;
1289
1290             CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
1291             CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
1292             CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
1293
1294             fCommandList.push_back(buffer);
1295         }
1296
1297         fDone = true;
1298
1299         return 0;
1300     }
1301
1302     int Write(detail::JackChannelTransactionInterface* trans)
1303     {
1304         if (trans == NULL)
1305         {
1306             fDone = true;
1307             return 0;
1308         }
1309
1310         char terminator[JACK_UUID_STRING_SIZE];
1311         memset(terminator, 0, sizeof(terminator));
1312
1313         CheckRes(JackResult::Write(trans));
1314         for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
1315             CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
1316             CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
1317             CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
1318             CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
1319         }
1320         CheckRes(trans->Write(terminator, sizeof(terminator)));
1321         return 0;
1322     }
1323
1324     jack_session_command_t* GetCommands()
1325     {
1326         /* TODO: some kind of signal should be used instead */
1327         while (!fDone)
1328         {
1329             JackSleep(50000);    /* 50 ms */
1330         }
1331
1332         jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
1333         int i = 0;
1334
1335         for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
1336             session_command[i].uuid = strdup(ci->fUUID);
1337             session_command[i].client_name = strdup(ci->fClientName);
1338             session_command[i].command = strdup(ci->fCommand);
1339             session_command[i].flags = ci->fFlags;
1340             i += 1;
1341         }
1342
1343         session_command[i].uuid = NULL;
1344         session_command[i].client_name = NULL;
1345         session_command[i].command = NULL;
1346         session_command[i].flags = (jack_session_flags_t)0;
1347
1348         return session_command;
1349     }
1350 };
1351
1352 /*!
1353 \brief SessionNotify request.
1354 */
1355
1356 struct JackSessionNotifyRequest : public JackRequest
1357 {
1358     char fPath[JACK_MESSAGE_SIZE+1];
1359     char fDst[JACK_CLIENT_NAME_SIZE+1];
1360     jack_session_event_type_t fEventType;
1361     int fRefNum;
1362
1363     JackSessionNotifyRequest() : fEventType(JackSessionSave), fRefNum(0)
1364     {}
1365     JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
1366             : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
1367     {
1368         memset(fPath, 0, sizeof(fPath));
1369         memset(fDst, 0, sizeof(fDst));
1370         strncpy(fPath, path, sizeof(fPath)-1);
1371         if (dst) {
1372             strncpy(fDst, dst, sizeof(fDst)-1);
1373         }
1374     }
1375
1376     int Read(detail::JackChannelTransactionInterface* trans)
1377     {
1378         CheckSize();
1379         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1380         CheckRes(trans->Read(&fPath, sizeof(fPath)));
1381         CheckRes(trans->Read(&fDst, sizeof(fDst)));
1382         CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
1383         return 0;
1384     }
1385
1386     int Write(detail::JackChannelTransactionInterface* trans)
1387     {
1388         CheckRes(JackRequest::Write(trans, Size()));
1389         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1390         CheckRes(trans->Write(&fPath, sizeof(fPath)));
1391         CheckRes(trans->Write(&fDst, sizeof(fDst)));
1392         CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
1393         return 0;
1394     }
1395
1396     int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
1397 };
1398
1399 struct JackSessionReplyRequest : public JackRequest
1400 {
1401     int fRefNum;
1402
1403     JackSessionReplyRequest() : fRefNum(0)
1404     {}
1405
1406     JackSessionReplyRequest(int refnum)
1407             : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
1408     {}
1409
1410     int Read(detail::JackChannelTransactionInterface* trans)
1411     {
1412         CheckSize();
1413         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1414         return 0;
1415     }
1416
1417     int Write(detail::JackChannelTransactionInterface* trans)
1418     {
1419         CheckRes(JackRequest::Write(trans, Size()));
1420         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1421         return 0;
1422     }
1423
1424     int Size() { return sizeof(int); }
1425
1426 };
1427
1428 struct JackClientNameResult : public JackResult
1429 {
1430     char fName[JACK_CLIENT_NAME_SIZE+1];
1431
1432     JackClientNameResult(): JackResult()
1433     {
1434         memset(fName, 0, sizeof(fName));
1435     }
1436     JackClientNameResult(int32_t result, const char* name)
1437             : JackResult(result)
1438     {
1439         memset(fName, 0, sizeof(fName));
1440         strncpy(fName, name, sizeof(fName)-1);
1441     }
1442
1443     int Read(detail::JackChannelTransactionInterface* trans)
1444     {
1445         CheckRes(JackResult::Read(trans));
1446         CheckRes(trans->Read(&fName, sizeof(fName)));
1447         return 0;
1448     }
1449
1450     int Write(detail::JackChannelTransactionInterface* trans)
1451     {
1452         CheckRes(JackResult::Write(trans));
1453         CheckRes(trans->Write(&fName, sizeof(fName)));
1454         return 0;
1455     }
1456
1457 };
1458
1459 struct JackUUIDResult : public JackResult
1460 {
1461     char fUUID[JACK_UUID_STRING_SIZE];
1462
1463     JackUUIDResult(): JackResult()
1464     {
1465         memset(fUUID, 0, sizeof(fUUID));
1466     }
1467     JackUUIDResult(int32_t result, const char* uuid)
1468             : JackResult(result)
1469     {
1470         memset(fUUID, 0, sizeof(fUUID));
1471         strncpy(fUUID, uuid, sizeof(fUUID)-1);
1472     }
1473
1474     int Read(detail::JackChannelTransactionInterface* trans)
1475     {
1476         CheckRes(JackResult::Read(trans));
1477         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1478         return 0;
1479     }
1480
1481     int Write(detail::JackChannelTransactionInterface* trans)
1482     {
1483         CheckRes(JackResult::Write(trans));
1484         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1485         return 0;
1486     }
1487
1488 };
1489
1490 struct JackGetUUIDRequest : public JackRequest
1491 {
1492     char fName[JACK_CLIENT_NAME_SIZE+1];
1493
1494     JackGetUUIDRequest()
1495     {
1496         memset(fName, 0, sizeof(fName));
1497     }
1498
1499     JackGetUUIDRequest(const char* client_name)
1500             : JackRequest(JackRequest::kGetUUIDByClient)
1501     {
1502         memset(fName, 0, sizeof(fName));
1503         strncpy(fName, client_name, sizeof(fName)-1);
1504     }
1505
1506     int Read(detail::JackChannelTransactionInterface* trans)
1507     {
1508         CheckSize();
1509         CheckRes(trans->Read(&fName, sizeof(fName)));
1510         return 0;
1511     }
1512
1513     int Write(detail::JackChannelTransactionInterface* trans)
1514     {
1515         CheckRes(JackRequest::Write(trans, Size()));
1516         CheckRes(trans->Write(&fName, sizeof(fName)));
1517         return 0;
1518     }
1519
1520     int Size() { return sizeof(fName); }
1521
1522 };
1523
1524 struct JackGetClientNameRequest : public JackRequest
1525 {
1526     char fUUID[JACK_UUID_STRING_SIZE];
1527
1528     JackGetClientNameRequest()
1529     {
1530         memset(fUUID, 0, sizeof(fUUID));
1531     }
1532
1533     JackGetClientNameRequest(const char* uuid)
1534             : JackRequest(JackRequest::kGetClientByUUID)
1535     {
1536         memset(fUUID, 0, sizeof(fUUID));
1537         strncpy(fUUID, uuid, sizeof(fUUID)-1);
1538     }
1539
1540     int Read(detail::JackChannelTransactionInterface* trans)
1541     {
1542         CheckSize();
1543         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1544         return 0;
1545     }
1546
1547     int Write(detail::JackChannelTransactionInterface* trans)
1548     {
1549         CheckRes(JackRequest::Write(trans, Size()));
1550         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1551         return 0;
1552     }
1553
1554     int Size() { return sizeof(fUUID); }
1555
1556 };
1557
1558 struct JackReserveNameRequest : public JackRequest
1559 {
1560     int  fRefNum;
1561     char fName[JACK_CLIENT_NAME_SIZE+1];
1562     char fUUID[JACK_UUID_STRING_SIZE];
1563
1564     JackReserveNameRequest() : fRefNum(0)
1565     {
1566         memset(fName, 0, sizeof(fName));
1567         memset(fUUID, 0, sizeof(fUUID));
1568     }
1569
1570     JackReserveNameRequest(int refnum, const char *name, const char* uuid)
1571             : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
1572     {
1573         memset(fName, 0, sizeof(fName));
1574         memset(fUUID, 0, sizeof(fUUID));
1575         strncpy(fName, name, sizeof(fName)-1);
1576         strncpy(fUUID, uuid, sizeof(fUUID)-1);
1577     }
1578
1579     int Read(detail::JackChannelTransactionInterface* trans)
1580     {
1581         CheckSize();
1582         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
1583         CheckRes(trans->Read(&fName, sizeof(fName)));
1584         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
1585         return 0;
1586     }
1587
1588     int Write(detail::JackChannelTransactionInterface* trans)
1589     {
1590         CheckRes(JackRequest::Write(trans, Size()));
1591         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
1592         CheckRes(trans->Write(&fName, sizeof(fName)));
1593         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
1594         return 0;
1595     }
1596
1597     int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
1598
1599 };
1600
1601 struct JackClientHasSessionCallbackRequest : public JackRequest
1602 {
1603     char fName[JACK_CLIENT_NAME_SIZE+1];
1604
1605     JackClientHasSessionCallbackRequest()
1606     {
1607         memset(fName, 0, sizeof(fName));
1608     }
1609
1610     JackClientHasSessionCallbackRequest(const char *name)
1611             : JackRequest(JackRequest::kClientHasSessionCallback)
1612     {
1613         memset(fName, 0, sizeof(fName));
1614         strncpy(fName, name, sizeof(fName)-1);
1615     }
1616
1617     int Read(detail::JackChannelTransactionInterface* trans)
1618     {
1619         CheckSize();
1620         CheckRes(trans->Read(&fName, sizeof(fName)));
1621         return 0;
1622     }
1623
1624     int Write(detail::JackChannelTransactionInterface* trans)
1625     {
1626         CheckRes(JackRequest::Write(trans, Size()));
1627         CheckRes(trans->Write(&fName, sizeof(fName)));
1628         return 0;
1629     }
1630
1631     int Size() { return sizeof(fName); }
1632
1633 };
1634
1635
1636 struct JackPropertyChangeNotifyRequest : public JackRequest
1637 {
1638     jack_uuid_t fSubject;
1639     char fKey[MAX_PATH+1];
1640     jack_property_change_t fChange;
1641
1642     JackPropertyChangeNotifyRequest() : fChange((jack_property_change_t)0)
1643     {
1644         jack_uuid_clear(&fSubject);
1645         memset(fKey, 0, sizeof(fKey));
1646     }
1647     JackPropertyChangeNotifyRequest(jack_uuid_t subject, const char* key, jack_property_change_t change)
1648         : JackRequest(JackRequest::kPropertyChangeNotify), fChange(change)
1649     {
1650         jack_uuid_copy(&fSubject, subject);
1651         memset(fKey, 0, sizeof(fKey));
1652         if (key)
1653             strncpy(fKey, key, sizeof(fKey)-1);
1654     }
1655
1656     int Read(detail::JackChannelTransactionInterface* trans)
1657     {
1658         CheckSize();
1659         CheckRes(trans->Read(&fSubject, sizeof(fSubject)));
1660         CheckRes(trans->Read(&fKey, sizeof(fKey)));
1661         CheckRes(trans->Read(&fChange, sizeof(fChange)));
1662         return 0;
1663     }
1664
1665     int Write(detail::JackChannelTransactionInterface* trans)
1666     {
1667         CheckRes(JackRequest::Write(trans, Size()));
1668         CheckRes(trans->Write(&fSubject, sizeof(fSubject)));
1669         CheckRes(trans->Write(&fKey, sizeof(fKey)));
1670         CheckRes(trans->Write(&fChange, sizeof(fChange)));
1671         return 0;
1672     }
1673
1674     int Size() { return sizeof(fSubject) + sizeof(fKey) + sizeof(fChange); }
1675 };
1676
1677 /*!
1678 \brief ClientNotification.
1679 */
1680
1681 struct JackClientNotification
1682 {
1683     int fSize;
1684     char fName[JACK_CLIENT_NAME_SIZE+1];
1685     int fRefNum;
1686     int fNotify;
1687     int fValue1;
1688     int fValue2;
1689     int fSync;
1690     char fMessage[JACK_MESSAGE_SIZE+1];
1691
1692     JackClientNotification(): fSize(0), fRefNum(0), fNotify(-1), fValue1(-1), fValue2(-1), fSync(0)
1693     {
1694         memset(fName, 0, sizeof(fName));
1695         memset(fMessage, 0, sizeof(fMessage));
1696     }
1697     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
1698             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
1699     {
1700         memset(fName, 0, sizeof(fName));
1701         memset(fMessage, 0, sizeof(fMessage));
1702         strncpy(fName, name, sizeof(fName)-1);
1703         if (message) {
1704             strncpy(fMessage, message, sizeof(fMessage)-1);
1705         }
1706         fSize = Size();
1707     }
1708
1709     int Read(detail::JackChannelTransactionInterface* trans)
1710     {
1711         CheckSize();
1712         CheckRes(trans->Read(&fName, sizeof(fName)));
1713         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1714         CheckRes(trans->Read(&fNotify, sizeof(int)));
1715         CheckRes(trans->Read(&fValue1, sizeof(int)));
1716         CheckRes(trans->Read(&fValue2, sizeof(int)));
1717         CheckRes(trans->Read(&fSync, sizeof(int)));
1718         CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
1719         return 0;
1720     }
1721
1722     int Write(detail::JackChannelTransactionInterface* trans)
1723     {
1724         CheckRes(trans->Write(&fSize, sizeof(int)));
1725         CheckRes(trans->Write(&fName, sizeof(fName)));
1726         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1727         CheckRes(trans->Write(&fNotify, sizeof(int)));
1728         CheckRes(trans->Write(&fValue1, sizeof(int)));
1729         CheckRes(trans->Write(&fValue2, sizeof(int)));
1730         CheckRes(trans->Write(&fSync, sizeof(int)));
1731         CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
1732         return 0;
1733     }
1734
1735     int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
1736
1737 };
1738
1739 } // end of namespace
1740
1741 #endif