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 "JackPlatformPlug.h"
  26 #include "types.h"
  27 #include <string.h>
  28 #include <stdio.h>
  29
  30 namespace Jack
  31 {
  32
  33 #define CheckRes(exp) { if ((exp) < 0) return -1;}
  34
  35 /*!
  36 \brief Request from client to server.
  37 */
  38
  39 struct JackRequest
  40 {
  41
  42     enum RequestType {
  43         kRegisterPort = 1,
  44         kUnRegisterPort = 2,
  45         kConnectPorts = 3,
  46         kDisconnectPorts = 4,
  47         kSetTimeBaseClient = 5,
  48         kActivateClient = 6,
  49         kDeactivateClient = 7,
  50         kDisconnectPort = 8,
  51         kSetClientCapabilities = 9,
  52         kGetPortConnections = 10,
  53         kGetPortNConnections = 11,
  54         kReleaseTimebase = 12,
  55         kSetTimebaseCallback = 13,
  56         kSetBufferSize = 20,
  57         kSetFreeWheel = 21,
  58         kClientCheck = 22,
  59         kClientOpen = 23,
  60         kClientClose = 24,
  61         kConnectNamePorts = 25,
  62         kDisconnectNamePorts = 26,
  63         kGetInternalClientName = 27,
  64         kInternalClientHandle = 28,
  65         kInternalClientLoad = 29,
  66         kInternalClientUnload = 30,
  67         kPortRename = 31,
  68         kNotification = 32
  69     };
  70
  71     RequestType fType;
  72
  73     JackRequest()
  74     {}
  75
  76     JackRequest(RequestType type): fType(type)
  77     {}
  78
  79     virtual ~JackRequest()
  80     {}
  81
  82     virtual int Read(JackChannelTransaction* trans)
  83     {
  84         return trans->Read(&fType, sizeof(RequestType));
  85     }
  86
  87     virtual int Write(JackChannelTransaction* trans)
  88     {
  89         return trans->Write(&fType, sizeof(RequestType));
  90     }
  91
  92 };
  93
  94 /*!
  95 \brief Result from the server.
  96 */
  97
  98 struct JackResult
  99 {
 100
 101     int fResult;
 102
 103     JackResult(): fResult( -1)
 104     {}
 105     JackResult(int result): fResult(result)
 106     {}
 107     virtual ~JackResult()
 108     {}
 109
 110     virtual int Read(JackChannelTransaction* trans)
 111     {
 112         return trans->Read(&fResult, sizeof(int));
 113     }
 114
 115     virtual int Write(JackChannelTransaction* trans)
 116     {
 117         return trans->Write(&fResult, sizeof(int));
 118     }
 119 };
 120
 121 /*!
 122 \brief CheckClient request.
 123 */
 124
 125 struct JackClientCheckRequest : public JackRequest
 126 {
 127
 128     char fName[JACK_CLIENT_NAME_SIZE + 1];
 129     int fProtocol;
 130     int fOptions;
 131
 132     JackClientCheckRequest()
 133     {}
 134     JackClientCheckRequest(const char* name, int protocol, int options)
 135         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options)
 136     {
 137         snprintf(fName, sizeof(fName), "%s", name);
 138     }
 139
 140     int Read(JackChannelTransaction* trans)
 141     {
 142         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
 143         CheckRes(trans->Read(&fProtocol, sizeof(int)));
 144         return trans->Read(&fOptions, sizeof(int));
 145     }
 146
 147     int Write(JackChannelTransaction* trans)
 148     {
 149         CheckRes(JackRequest::Write(trans));
 150         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
 151         CheckRes(trans->Write(&fProtocol, sizeof(int)));
 152         return trans->Write(&fOptions, sizeof(int));
 153     }
 154 };
 155
 156 /*!
 157 \brief CheckClient result.
 158 */
 159
 160 struct JackClientCheckResult : public JackResult
 161 {
 162
 163     char fName[JACK_CLIENT_NAME_SIZE + 1];
 164     int fStatus;
 165
 166     JackClientCheckResult(): JackResult(), fStatus(0)
 167     {}
 168     JackClientCheckResult(int32_t result, const char* name, int status)
 169             : JackResult(result), fStatus(status)
 170     {
 171         snprintf(fName, sizeof(fName), "%s", name);
 172     }
 173
 174     int Read(JackChannelTransaction* trans)
 175     {
 176         CheckRes(JackResult::Read(trans));
 177         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
 178         CheckRes(trans->Read(&fStatus, sizeof(int)));
 179         return 0;
 180     }
 181
 182     int Write(JackChannelTransaction* trans)
 183     {
 184         CheckRes(JackResult::Write(trans));
 185         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
 186         CheckRes(trans->Write(&fStatus, sizeof(int)));
 187         return 0;
 188     }
 189 };
 190
 191 /*!
 192 \brief NewClient request.
 193 */
 194
 195 struct JackClientOpenRequest : public JackRequest
 196 {
 197
 198     int fPID;
 199     char fName[JACK_CLIENT_NAME_SIZE + 1];
 200
 201     JackClientOpenRequest()
 202     {}
 203     JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
 204     {
 205         snprintf(fName, sizeof(fName), "%s", name);
 206         fPID = pid;
 207     }
 208
 209     int Read(JackChannelTransaction* trans)
 210     {
 211         CheckRes(trans->Read(&fPID, sizeof(int)));
 212         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
 213     }
 214
 215     int Write(JackChannelTransaction* trans)
 216     {
 217         CheckRes(JackRequest::Write(trans));
 218         CheckRes(trans->Write(&fPID, sizeof(int)));
 219         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
 220     }
 221 };
 222
 223 /*!
 224 \brief NewClient result.
 225 */
 226
 227 struct JackClientOpenResult : public JackResult
 228 {
 229
 230     int fSharedEngine;
 231     int fSharedClient;
 232     int fSharedGraph;
 233
 234     JackClientOpenResult()
 235             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
 236     {}
 237     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
 238             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
 239     {}
 240
 241     int Read(JackChannelTransaction* trans)
 242     {
 243         CheckRes(JackResult::Read(trans));
 244         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
 245         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
 246         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
 247         return 0;
 248     }
 249
 250     int Write(JackChannelTransaction* trans)
 251     {
 252         CheckRes(JackResult::Write(trans));
 253         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
 254         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
 255         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
 256         return 0;
 257     }
 258 };
 259
 260 /*!
 261 \brief CloseClient request.
 262 */
 263
 264 struct JackClientCloseRequest : public JackRequest
 265 {
 266
 267     int fRefNum;
 268
 269     JackClientCloseRequest()
 270     {}
 271     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
 272     {}
 273
 274     int Read(JackChannelTransaction* trans)
 275     {
 276         return trans->Read(&fRefNum, sizeof(int));
 277     }
 278
 279     int Write(JackChannelTransaction* trans)
 280     {
 281         CheckRes(JackRequest::Write(trans));
 282         return trans->Write(&fRefNum, sizeof(int));
 283     }
 284 };
 285
 286 /*!
 287 \brief Activate request.
 288 */
 289
 290 struct JackActivateRequest : public JackRequest
 291 {
 292
 293     int fRefNum;
 294     int fState;
 295
 296     JackActivateRequest()
 297     {}
 298     JackActivateRequest(int refnum, int state)
 299         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fState(state)
 300     {}
 301
 302     int Read(JackChannelTransaction* trans)
 303     {
 304         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 305         return trans->Read(&fState, sizeof(int));
 306     }
 307
 308     int Write(JackChannelTransaction* trans)
 309     {
 310         CheckRes(JackRequest::Write(trans));
 311         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 312         return trans->Write(&fState, sizeof(int));
 313     }
 314
 315 };
 316
 317 /*!
 318 \brief Deactivate request.
 319 */
 320
 321 struct JackDeactivateRequest : public JackRequest
 322 {
 323
 324     int fRefNum;
 325
 326     JackDeactivateRequest()
 327     {}
 328     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
 329     {}
 330
 331     int Read(JackChannelTransaction* trans)
 332     {
 333         return trans->Read(&fRefNum, sizeof(int));
 334     }
 335
 336     int Write(JackChannelTransaction* trans)
 337     {
 338         CheckRes(JackRequest::Write(trans));
 339         return trans->Write(&fRefNum, sizeof(int));
 340     }
 341
 342 };
 343
 344 /*!
 345 \brief PortRegister request.
 346 */
 347
 348 struct JackPortRegisterRequest : public JackRequest
 349 {
 350
 351     int fRefNum;
 352     char fName[JACK_PORT_NAME_SIZE + 1];
 353     char fPortType[JACK_PORT_TYPE_SIZE + 1];
 354     unsigned int fFlags;
 355     unsigned int fBufferSize;
 356
 357     JackPortRegisterRequest()
 358     {}
 359     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
 360             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
 361     {
 362         strcpy(fName, name);
 363         strcpy(fPortType, port_type);
 364     }
 365
 366     int Read(JackChannelTransaction* trans)
 367     {
 368         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 369         CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
 370         CheckRes(trans->Read(&fPortType, JACK_PORT_TYPE_SIZE + 1));
 371         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
 372         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
 373         return 0;
 374     }
 375
 376     int Write(JackChannelTransaction* trans)
 377     {
 378         CheckRes(JackRequest::Write(trans));
 379         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 380         CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
 381         CheckRes(trans->Write(&fPortType, JACK_PORT_TYPE_SIZE + 1));
 382         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
 383         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
 384         return 0;
 385     }
 386 };
 387
 388 /*!
 389 \brief PortRegister result.
 390 */
 391
 392 struct JackPortRegisterResult : public JackResult
 393 {
 394
 395     jack_port_id_t fPortIndex;
 396
 397     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
 398     {}
 399
 400     int Read(JackChannelTransaction* trans)
 401     {
 402         CheckRes(JackResult::Read(trans));
 403         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
 404     }
 405
 406     int Write(JackChannelTransaction* trans)
 407     {
 408         CheckRes(JackResult::Write(trans));
 409         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
 410     }
 411 };
 412
 413 /*!
 414 \brief PortUnregister request.
 415 */
 416
 417 struct JackPortUnRegisterRequest : public JackRequest
 418 {
 419
 420     int fRefNum;
 421     jack_port_id_t fPortIndex;
 422
 423     JackPortUnRegisterRequest()
 424     {}
 425     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
 426         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
 427     {}
 428
 429     int Read(JackChannelTransaction* trans)
 430     {
 431         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 432         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
 433         return 0;
 434     }
 435
 436     int Write(JackChannelTransaction* trans)
 437     {
 438         CheckRes(JackRequest::Write(trans));
 439         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 440         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
 441         return 0;
 442     }
 443 };
 444
 445 /*!
 446 \brief PortConnectName request.
 447 */
 448
 449 struct JackPortConnectNameRequest : public JackRequest
 450 {
 451
 452     int fRefNum;
 453     char fSrc[JACK_PORT_NAME_SIZE + 1];
 454     char fDst[JACK_PORT_NAME_SIZE + 1];
 455
 456     JackPortConnectNameRequest()
 457     {}
 458     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
 459         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
 460     {
 461         strcpy(fSrc, src_name);
 462         strcpy(fDst, dst_name);
 463     }
 464
 465     int Read(JackChannelTransaction* trans)
 466     {
 467         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 468         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
 469         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
 470         return 0;
 471
 472     }
 473
 474     int Write(JackChannelTransaction* trans)
 475     {
 476         CheckRes(JackRequest::Write(trans));
 477         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 478         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
 479         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
 480         return 0;
 481     }
 482 };
 483
 484 /*!
 485 \brief PortDisconnectName request.
 486 */
 487
 488 struct JackPortDisconnectNameRequest : public JackRequest
 489 {
 490
 491     int fRefNum;
 492     char fSrc[JACK_PORT_NAME_SIZE + 1];
 493     char fDst[JACK_PORT_NAME_SIZE + 1];
 494
 495     JackPortDisconnectNameRequest()
 496     {}
 497     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
 498         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
 499     {
 500         strcpy(fSrc, src_name);
 501         strcpy(fDst, dst_name);
 502     }
 503
 504     int Read(JackChannelTransaction* trans)
 505     {
 506         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 507         CheckRes(trans->Read(&fSrc, JACK_PORT_NAME_SIZE + 1));
 508         CheckRes(trans->Read(&fDst, JACK_PORT_NAME_SIZE + 1));
 509         return 0;
 510     }
 511
 512     int Write(JackChannelTransaction* trans)
 513     {
 514         CheckRes(JackRequest::Write(trans));
 515         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 516         CheckRes(trans->Write(&fSrc, JACK_PORT_NAME_SIZE + 1));
 517         CheckRes(trans->Write(&fDst, JACK_PORT_NAME_SIZE + 1));
 518         return 0;
 519     }
 520 };
 521
 522 /*!
 523 \brief PortConnect request.
 524 */
 525
 526 struct JackPortConnectRequest : public JackRequest
 527 {
 528
 529     int fRefNum;
 530     jack_port_id_t fSrc;
 531     jack_port_id_t fDst;
 532
 533     JackPortConnectRequest()
 534     {}
 535     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
 536         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
 537     {}
 538
 539     int Read(JackChannelTransaction* trans)
 540     {
 541         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 542         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
 543         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
 544         return 0;
 545     }
 546
 547     int Write(JackChannelTransaction* trans)
 548     {
 549         CheckRes(JackRequest::Write(trans));
 550         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 551         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
 552         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
 553         return 0;
 554     }
 555 };
 556
 557
 558 /*!
 559 \brief PortDisconnect request.
 560 */
 561
 562 struct JackPortDisconnectRequest : public JackRequest
 563 {
 564
 565     int fRefNum;
 566     jack_port_id_t fSrc;
 567     jack_port_id_t fDst;
 568
 569     JackPortDisconnectRequest()
 570     {}
 571     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
 572         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
 573     {}
 574
 575     int Read(JackChannelTransaction* trans)
 576     {
 577         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 578         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
 579         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
 580         return 0;
 581     }
 582
 583     int Write(JackChannelTransaction* trans)
 584     {
 585         CheckRes(JackRequest::Write(trans));
 586         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 587         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
 588         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
 589         return 0;
 590
 591     }
 592 };
 593
 594 /*!
 595 \brief PortRename request.
 596 */
 597
 598 struct JackPortRenameRequest : public JackRequest
 599 {
 600
 601     int fRefNum;
 602     jack_port_id_t fPort;
 603     char fName[JACK_PORT_NAME_SIZE + 1];
 604
 605     JackPortRenameRequest()
 606     {}
 607     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
 608         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
 609     {
 610         strcpy(fName, name);
 611     }
 612
 613     int Read(JackChannelTransaction* trans)
 614     {
 615         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 616         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
 617         CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
 618         return 0;
 619     }
 620
 621     int Write(JackChannelTransaction* trans)
 622     {
 623         CheckRes(JackRequest::Write(trans));
 624         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 625         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
 626         CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
 627         return 0;
 628
 629     }
 630 };
 631
 632 /*!
 633 \brief SetBufferSize request.
 634 */
 635
 636 struct JackSetBufferSizeRequest : public JackRequest
 637 {
 638
 639     jack_nframes_t fBufferSize;
 640
 641     JackSetBufferSizeRequest()
 642     {}
 643     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
 644         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
 645     {}
 646
 647     int Read(JackChannelTransaction* trans)
 648     {
 649         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
 650     }
 651
 652     int Write(JackChannelTransaction* trans)
 653     {
 654         CheckRes(JackRequest::Write(trans));
 655         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
 656     }
 657 };
 658
 659 /*!
 660 \brief SetFreeWheel request.
 661 */
 662
 663 struct JackSetFreeWheelRequest : public JackRequest
 664 {
 665
 666     int fOnOff;
 667
 668     JackSetFreeWheelRequest()
 669     {}
 670     JackSetFreeWheelRequest(int onoff)
 671         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
 672     {}
 673
 674     int Read(JackChannelTransaction* trans)
 675     {
 676         return trans->Read(&fOnOff, sizeof(int));
 677     }
 678
 679     int Write(JackChannelTransaction* trans)
 680     {
 681         CheckRes(JackRequest::Write(trans));
 682         return trans->Write(&fOnOff, sizeof(int));
 683     }
 684 };
 685
 686 /*!
 687 \brief ReleaseTimebase request.
 688 */
 689
 690 struct JackReleaseTimebaseRequest : public JackRequest
 691 {
 692
 693     int fRefNum;
 694
 695     JackReleaseTimebaseRequest()
 696     {}
 697     JackReleaseTimebaseRequest(int refnum)
 698         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
 699     {}
 700
 701     int Read(JackChannelTransaction* trans)
 702     {
 703         return trans->Read(&fRefNum, sizeof(int));
 704     }
 705
 706     int Write(JackChannelTransaction* trans)
 707     {
 708         CheckRes(JackRequest::Write(trans));
 709         return trans->Write(&fRefNum, sizeof(int));
 710     }
 711 };
 712
 713 /*!
 714 \brief SetTimebaseCallback request.
 715 */
 716
 717 struct JackSetTimebaseCallbackRequest : public JackRequest
 718 {
 719
 720     int fRefNum;
 721     int fConditionnal;
 722
 723     JackSetTimebaseCallbackRequest()
 724     {}
 725     JackSetTimebaseCallbackRequest(int refnum, int conditional)
 726         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
 727     {}
 728
 729     int Read(JackChannelTransaction* trans)
 730     {
 731         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 732         return trans->Read(&fConditionnal, sizeof(int));
 733     }
 734
 735     int Write(JackChannelTransaction* trans)
 736     {
 737         CheckRes(JackRequest::Write(trans));
 738         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 739         return trans->Write(&fConditionnal, sizeof(int));
 740     }
 741 };
 742
 743 /*!
 744 \brief GetInternalClientName request.
 745 */
 746
 747 struct JackGetInternalClientNameRequest : public JackRequest
 748 {
 749
 750     int fRefNum;
 751     int fIntRefNum;
 752
 753     JackGetInternalClientNameRequest()
 754     {}
 755     JackGetInternalClientNameRequest(int refnum, int int_ref)
 756             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
 757     {}
 758
 759     int Read(JackChannelTransaction* trans)
 760     {
 761         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 762         return trans->Read(&fIntRefNum, sizeof(int));
 763     }
 764
 765     int Write(JackChannelTransaction* trans)
 766     {
 767         CheckRes(JackRequest::Write(trans));
 768         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 769         return trans->Write(&fIntRefNum, sizeof(int));
 770     }
 771 };
 772
 773 /*!
 774 \brief GetInternalClient result.
 775 */
 776
 777 struct JackGetInternalClientNameResult : public JackResult
 778 {
 779
 780     char fName[JACK_CLIENT_NAME_SIZE + 1];
 781
 782     JackGetInternalClientNameResult(): JackResult()
 783     {}
 784     JackGetInternalClientNameResult(int32_t result, const char* name)
 785             : JackResult(result)
 786     {
 787         snprintf(fName, sizeof(fName), "%s", name);
 788     }
 789
 790     int Read(JackChannelTransaction* trans)
 791     {
 792         CheckRes(JackResult::Read(trans));
 793         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
 794         return 0;
 795     }
 796
 797     int Write(JackChannelTransaction* trans)
 798     {
 799         CheckRes(JackResult::Write(trans));
 800         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
 801         return 0;
 802     }
 803 };
 804
 805 /*!
 806 \brief InternalClientHandle request.
 807 */
 808
 809 struct JackInternalClientHandleRequest : public JackRequest
 810 {
 811
 812     int fRefNum;
 813     char fName[JACK_CLIENT_NAME_SIZE + 1];
 814
 815     JackInternalClientHandleRequest()
 816     {}
 817     JackInternalClientHandleRequest(int refnum, const char* client_name)
 818             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
 819     {
 820         snprintf(fName, sizeof(fName), "%s", client_name);
 821     }
 822
 823     int Read(JackChannelTransaction* trans)
 824     {
 825         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 826         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
 827     }
 828
 829     int Write(JackChannelTransaction* trans)
 830     {
 831         CheckRes(JackRequest::Write(trans));
 832         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 833         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
 834     }
 835 };
 836
 837 /*!
 838 \brief InternalClientHandle result.
 839 */
 840
 841 struct JackInternalClientHandleResult : public JackResult
 842 {
 843
 844     int fStatus;
 845     int fIntRefNum;
 846
 847     JackInternalClientHandleResult(): JackResult()
 848     {}
 849     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
 850             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
 851     {}
 852
 853     int Read(JackChannelTransaction* trans)
 854     {
 855         CheckRes(JackResult::Read(trans));
 856         CheckRes(trans->Read(&fStatus, sizeof(int)));
 857         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
 858         return 0;
 859     }
 860
 861     int Write(JackChannelTransaction* trans)
 862     {
 863         CheckRes(JackResult::Write(trans));
 864         CheckRes(trans->Write(&fStatus, sizeof(int)));
 865         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
 866         return 0;
 867     }
 868 };
 869
 870 /*!
 871 \brief InternalClientLoad request.
 872 */
 873
 874 struct JackInternalClientLoadRequest : public JackRequest
 875 {
 876
 877 #ifndef MAX_PATH
 878 #define MAX_PATH 256
 879 #endif
 880
 881     int fRefNum;
 882     char fName[JACK_CLIENT_NAME_SIZE + 1];
 883     char fDllName[MAX_PATH + 1];
 884     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
 885     int fOptions;
 886
 887     JackInternalClientLoadRequest()
 888     {}
 889     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
 890             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
 891     {
 892         snprintf(fName, sizeof(fName), "%s", client_name);
 893         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
 894         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
 895     }
 896
 897     int Read(JackChannelTransaction* trans)
 898     {
 899         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 900         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
 901         CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
 902         CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
 903         return trans->Read(&fOptions, sizeof(int));
 904     }
 905
 906     int Write(JackChannelTransaction* trans)
 907     {
 908         CheckRes(JackRequest::Write(trans));
 909         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 910         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
 911         CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
 912         CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
 913         return trans->Write(&fOptions, sizeof(int));
 914     }
 915 };
 916
 917 /*!
 918 \brief InternalClientLoad result.
 919 */
 920
 921 struct JackInternalClientLoadResult : public JackResult
 922 {
 923
 924     int fStatus;
 925     int fIntRefNum;
 926
 927     JackInternalClientLoadResult(): JackResult()
 928     {}
 929     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
 930             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
 931     {}
 932
 933     int Read(JackChannelTransaction* trans)
 934     {
 935         CheckRes(JackResult::Read(trans));
 936         CheckRes(trans->Read(&fStatus, sizeof(int)));
 937         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
 938         return 0;
 939     }
 940
 941     int Write(JackChannelTransaction* trans)
 942     {
 943         CheckRes(JackResult::Write(trans));
 944         CheckRes(trans->Write(&fStatus, sizeof(int)));
 945         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
 946         return 0;
 947     }
 948 };
 949
 950 /*!
 951 \brief InternalClientUnload request.
 952 */
 953
 954 struct JackInternalClientUnloadRequest : public JackRequest
 955 {
 956
 957     int fRefNum;
 958     int fIntRefNum;
 959
 960     JackInternalClientUnloadRequest()
 961     {}
 962     JackInternalClientUnloadRequest(int refnum, int int_ref)
 963             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
 964     {}
 965
 966     int Read(JackChannelTransaction* trans)
 967     {
 968         CheckRes(trans->Read(&fRefNum, sizeof(int)));
 969         return trans->Read(&fIntRefNum, sizeof(int));
 970     }
 971
 972     int Write(JackChannelTransaction* trans)
 973     {
 974         CheckRes(JackRequest::Write(trans));
 975         CheckRes(trans->Write(&fRefNum, sizeof(int)));
 976         return trans->Write(&fIntRefNum, sizeof(int));
 977     }
 978 };
 979
 980
 981 /*!
 982 \brief InternalClientLoad result.
 983 */
 984
 985 struct JackInternalClientUnloadResult : public JackResult
 986 {
 987
 988     int fStatus;
 989
 990     JackInternalClientUnloadResult(): JackResult()
 991     {}
 992     JackInternalClientUnloadResult(int32_t result, int status)
 993             : JackResult(result), fStatus(status)
 994     {}
 995
 996     int Read(JackChannelTransaction* trans)
 997     {
 998         CheckRes(JackResult::Read(trans));
 999         CheckRes(trans->Read(&fStatus, sizeof(int)));
1000         return 0;
1001     }
1002
1003     int Write(JackChannelTransaction* trans)
1004     {
1005         CheckRes(JackResult::Write(trans));
1006         CheckRes(trans->Write(&fStatus, sizeof(int)));
1007         return 0;
1008     }
1009 };
1010
1011 /*!
1012 \brief ClientNotification request.
1013 */
1014
1015 struct JackClientNotificationRequest : public JackRequest
1016 {
1017
1018     int fRefNum;
1019     int fNotify;
1020     int fValue;
1021
1022     JackClientNotificationRequest()
1023     {}
1024     JackClientNotificationRequest(int refnum, int notify, int value)
1025             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
1026     {}
1027
1028     int Read(JackChannelTransaction* trans)
1029     {
1030         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1031         CheckRes(trans->Read(&fNotify, sizeof(int)));
1032         CheckRes(trans->Read(&fValue, sizeof(int)));
1033         return 0;
1034     }
1035
1036     int Write(JackChannelTransaction* trans)
1037     {
1038         CheckRes(JackRequest::Write(trans));
1039         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1040         CheckRes(trans->Write(&fNotify, sizeof(int)));
1041         CheckRes(trans->Write(&fValue, sizeof(int)));
1042         return 0;
1043     }
1044
1045 };
1046
1047 /*!
1048 \brief ClientNotification.
1049 */
1050
1051 struct JackClientNotification
1052 {
1053     char fName[JACK_CLIENT_NAME_SIZE + 1];
1054     int fRefNum;
1055     int fNotify;
1056     int fValue1;
1057     int fValue2;
1058     int fSync;
1059
1060     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
1061     {}
1062     JackClientNotification(const char* name, int refnum, int notify, int sync, int value1, int value2)
1063             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
1064     {
1065         snprintf(fName, sizeof(fName), "%s", name);
1066     }
1067
1068     int Read(JackChannelTransaction* trans)
1069     {
1070         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
1071         CheckRes(trans->Read(&fRefNum, sizeof(int)));
1072         CheckRes(trans->Read(&fNotify, sizeof(int)));
1073         CheckRes(trans->Read(&fValue1, sizeof(int)));
1074         CheckRes(trans->Read(&fValue2, sizeof(int)));
1075         CheckRes(trans->Read(&fSync, sizeof(int)));
1076         return 0;
1077     }
1078
1079     int Write(JackChannelTransaction* trans)
1080     {
1081         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
1082         CheckRes(trans->Write(&fRefNum, sizeof(int)));
1083         CheckRes(trans->Write(&fNotify, sizeof(int)));
1084         CheckRes(trans->Write(&fValue1, sizeof(int)));
1085         CheckRes(trans->Write(&fValue2, sizeof(int)));
1086         CheckRes(trans->Write(&fSync, sizeof(int)));
1087         return 0;
1088     }
1089
1090 };
1091
1092 } // end of namespace
1093
1094 #endif