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