Browse Source

OSX IPC code removed from repository.

tags/1.9.7
Stéphane LETZ Torben Hohn 15 years ago
parent
commit
e4ef948ea3
24 changed files with 5 additions and 18229 deletions
  1. +5
    -9
      common/wscript
  2. +0
    -250
      macosx/JackMacEngineRPC.cpp
  3. +0
    -47
      macosx/JackMacLibClientRPC.cpp
  4. +0
    -348
      macosx/JackMachClientChannel.cpp
  5. +0
    -99
      macosx/JackMachClientChannel.h
  6. +0
    -67
      macosx/JackMachNotifyChannel.cpp
  7. +0
    -53
      macosx/JackMachNotifyChannel.h
  8. +0
    -295
      macosx/JackMachPort.cpp
  9. +0
    -88
      macosx/JackMachPort.h
  10. +0
    -174
      macosx/JackMachServerChannel.cpp
  11. +0
    -76
      macosx/JackMachServerChannel.h
  12. +0
    -70
      macosx/JackMachServerNotifyChannel.cpp
  13. +0
    -55
      macosx/JackMachServerNotifyChannel.h
  14. +0
    -25
      macosx/JackPlatformPlug_os.h
  15. +0
    -128
      macosx/Jackdmp.xcodeproj/project.pbxproj
  16. +0
    -47
      macosx/RPC/JackRPCClient.defs
  17. +0
    -194
      macosx/RPC/JackRPCClient.h
  18. +0
    -1373
      macosx/RPC/JackRPCClientServer.c
  19. +0
    -466
      macosx/RPC/JackRPCClientUser.c
  20. +0
    -181
      macosx/RPC/JackRPCEngine.defs
  21. +0
    -1040
      macosx/RPC/JackRPCEngine.h
  22. +0
    -6817
      macosx/RPC/JackRPCEngineServer.c
  23. +0
    -6302
      macosx/RPC/JackRPCEngineUser.c
  24. +0
    -25
      macosx/RPC/Jackdefs.h

+ 5
- 9
common/wscript View File

@@ -97,7 +97,7 @@ def build(bld):
'../posix/JackPosixThread.cpp',
'../macosx/JackMachThread.cpp',
'../macosx/JackMachSemaphore.cpp',
'../macosx/JackMachPort.cpp',
'../posix/JackSocket.cpp',
'../macosx/JackMachTime.c',
]
includes = ['../macosx', '../macosx/RPC', '../posix'] + includes
@@ -152,11 +152,9 @@ def build(bld):

if bld.env['IS_MACOSX']:
serverlib.source += [
'../macosx/JackMachServerChannel.cpp',
'../macosx/JackMachNotifyChannel.cpp',
'../macosx/JackMachServerNotifyChannel.cpp',
'../macosx/JackMacEngineRPC.cpp',
'../macosx/RPC/JackRPCClientUser.c',
'../posix/JackSocketServerChannel.cpp',
'../posix/JackSocketNotifyChannel.cpp',
'../posix/JackSocketServerNotifyChannel.cpp',
'../posix/JackNetUnixSocket.cpp',
]

@@ -205,9 +203,7 @@ def build(bld):

if bld.env['IS_MACOSX']:
clientlib.source += [
'../macosx/JackMachClientChannel.cpp',
'../macosx/RPC/JackRPCEngineUser.c',
'../macosx/JackMacLibClientRPC.cpp',
'../posix/JackSocketClientChannel.cpp',
'../posix/JackPosixServerLaunch.cpp',
]



+ 0
- 250
macosx/JackMacEngineRPC.cpp View File

@@ -1,250 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "JackServer.h"
#include "JackNotification.h"
#include "JackLockedEngine.h"
#include "JackRPCEngine.h"
#include "JackMachServerChannel.h"
#include "JackException.h"
#include <assert.h>

using namespace Jack;

//-------------------
// Client management
//-------------------

#define rpc_type kern_return_t // for astyle

rpc_type server_rpc_jack_client_check(mach_port_t private_port, client_name_t name, client_name_t name_res, int protocol, int options, int* status, int* result)
{
jack_log("rpc_jack_client_check");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
channel->ClientCheck((char*)name, (char*)name_res, protocol, options, status, result);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_client_open(mach_port_t server_port, client_name_t name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
{
jack_log("rpc_jack_client_open name = %s", name);
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
assert(channel);
channel->ClientOpen((char*)name, pid, private_port, shared_engine, shared_client, shared_graph, result);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
{
jack_log("rpc_jack_client_close");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
channel->ClientClose(private_port, refnum);
*result = 0;
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int is_real_time, int* result)
{
jack_log("rpc_jack_client_activate");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->ClientActivate(refnum, is_real_time);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
{
jack_log("rpc_jack_client_deactivate");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->ClientDeactivate(refnum);
return KERN_SUCCESS;
}

//-----------------
// Port management
//-----------------

rpc_type server_rpc_jack_port_register(mach_port_t private_port, int refnum, client_port_name_t name, client_port_type_t type, unsigned int flags, unsigned int buffer_size, unsigned int* port_index, int* result)
{
jack_log("rpc_jack_port_register ref = %d name = %s", refnum, name);
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortRegister(refnum, name, type, flags, buffer_size, port_index);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
{
jack_log("rpc_jack_port_unregister ref = %d port = %d ", refnum, port);
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortUnRegister(refnum, port);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_connect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
{
jack_log("rpc_jack_port_connect_name");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortConnect(refnum, src, dst);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_disconnect_name(mach_port_t private_port, int refnum, client_port_name_t src, client_port_name_t dst, int* result)
{
jack_log("rpc_jack_port_disconnect_name");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
{
jack_log("rpc_jack_port_connect");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortConnect(refnum, src, dst);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
{
jack_log("rpc_jack_port_disconnect");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
{
jack_log("server_rpc_jack_port_rename");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetEngine()->PortRename(refnum, port, name);
return KERN_SUCCESS;
}

//------------------------
// Buffer size, freewheel
//------------------------

rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
{
jack_log("server_rpc_jack_set_buffer_size");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->SetBufferSize(buffer_size);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
{
jack_log("server_rpc_jack_set_freewheel");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->SetFreewheel(onoff);
return KERN_SUCCESS;
}

//----------------------
// Transport management
//----------------------

rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
{
jack_log("server_rpc_jack_release_timebase");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->ReleaseTimebase(refnum);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
{
jack_log("server_rpc_jack_set_timebase_callback");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->SetTimebaseCallback(refnum, conditional);
return KERN_SUCCESS;
}

//------------------
// Internal clients
//------------------

rpc_type server_rpc_jack_get_internal_clientname(mach_port_t private_port, int refnum, int int_ref, client_name_t name_res, int* result)
{
jack_log("server_rpc_jack_get_internal_clientname");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->GetEngine()->GetInternalClientName(int_ref, (char*)name_res);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_internal_clienthandle(mach_port_t private_port, int refnum, client_name_t client_name, int* status, int* int_ref, int* result)
{
jack_log("server_rpc_jack_internal_clienthandle");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->GetEngine()->InternalClientHandle(client_name, status, int_ref);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_internal_clientload(mach_port_t private_port, int refnum, client_name_t client_name, so_name_t so_name, objet_data_t objet_data, int options, int* status, int* int_ref, int* result)
{
jack_log("server_rpc_jack_internal_clientload");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);
return KERN_SUCCESS;
}

rpc_type server_rpc_jack_internal_clientunload(mach_port_t private_port, int refnum, int int_ref, int* status, int* result)
{
jack_log("server_rpc_jack_internal_clientunload");
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
assert(channel);
*result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status);
return KERN_SUCCESS;
}

//-----------------
// RT notification
//-----------------

rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
{
jack_log("rpc_jack_client_rt_notify ref = %d notify = %d value = %d", refnum, notify, value);
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
assert(channel);
assert(channel->GetServer());
if (notify == kQUIT) {
throw JackQuitException();
} else {
channel->GetServer()->Notify(refnum, notify, value);
return KERN_SUCCESS;
}
}

+ 0
- 47
macosx/JackMacLibClientRPC.cpp View File

@@ -1,47 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "JackLibClient.h"
#include "JackMachClientChannel.h"
#include "JackRPCEngine.h"
#include "JackLibGlobals.h"
#include <assert.h>

using namespace Jack;

#define rpc_type kern_return_t // for astyle

rpc_type rpc_jack_client_sync_notify(mach_port_t client_port, int refnum, client_name_t name, int notify, message_t message, int value1, int value2, int* result)
{
jack_log("rpc_jack_client_sync_notify ref = %ld name = %s notify = %ld message %s val1 = %ld val2 = %ld", refnum, name, notify, message, value1, value2);
JackClient* client = gClientTable[client_port];
assert(client);
*result = client->ClientNotify(refnum, name, notify, true, message, value1, value2);
return KERN_SUCCESS;
}

rpc_type rpc_jack_client_async_notify(mach_port_t client_port, int refnum, client_name_t name, int notify, message_t message, int value1, int value2)
{
jack_log("rpc_jack_client_async_notify ref = %ld name = %s notify = %ld message %s val1 = %ld val2 = %ld", refnum, name, notify, message, value1, value2);
JackClient* client = gClientTable[client_port];
assert(client);
client->ClientNotify(refnum, name, notify, false, message, value1, value2);
return KERN_SUCCESS;
}


+ 0
- 348
macosx/JackMachClientChannel.cpp View File

@@ -1,348 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackMachClientChannel.h"
#include "JackRPCEngine.h"
#include "JackTools.h"
#include "JackRPCClientServer.c"
#include "JackError.h"
#include "JackLibClient.h"
#include "JackMachThread.h"
#include "JackConstants.h"

namespace Jack
{

std::map<mach_port_t, JackClient*> gClientTable;

JackMachClientChannel::JackMachClientChannel():fPrivatePort(0),fThread(this)
{}

JackMachClientChannel::~JackMachClientChannel()
{}

// Server <===> client

int JackMachClientChannel::ServerCheck(const char* server_name)
{
jack_log("JackMachClientChannel::ServerCheck = %s", server_name);
char jack_server_entry_name[512];
snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);

// Connect to server
if (!fServerPort.ConnectPort(jack_server_entry_name)) {
jack_error("Cannot connect to server Mach port");
return -1;
} else {
return 0;
}
}

int JackMachClientChannel::Open(const char* server_name, const char* name, char* name_res, JackClient* client, jack_options_t options, jack_status_t* status)
{
jack_log("JackMachClientChannel::Open name = %s", name);
char jack_server_entry_name[512];
snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);

// Connect to server
if (!fServerPort.ConnectPort(jack_server_entry_name)) {
jack_error("Cannot connect to server Mach port");
return -1;
}

// Check name in server
int result = 0;
ClientCheck(name, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result);
if (result < 0) {
int status1 = *status;
if (status1 & JackVersionError)
jack_error("JACK protocol mismatch %d", JACK_PROTOCOL_VERSION);
else
jack_error("Client name = %s conflits with another running client", name);
return -1;
}

// Prepare local port using client name
char buf[JACK_CLIENT_NAME_SIZE + 1];
snprintf(buf, sizeof(buf) - 1, "%s:%s", jack_client_entry, name_res);

if (!fClientPort.AllocatePort(buf, 16)) {
jack_error("Cannot allocate client Mach port");
return -1;
}

gClientTable[fClientPort.GetPort()] = client;
return 0;
}

void JackMachClientChannel::Close()
{
jack_log("JackMachClientChannel::Close");
gClientTable.erase(fClientPort.GetPort());
fServerPort.DisconnectPort();
fClientPort.DestroyPort();

if (fPrivatePort != 0) {
kern_return_t res;
if ((res = mach_port_destroy(mach_task_self(), fPrivatePort)) != KERN_SUCCESS) {
jack_error("JackMachClientChannel::Close err = %s", mach_error_string(res));
}
}
}

int JackMachClientChannel::Start()
{
jack_log("JackMachClientChannel::Start");
/*
To be sure notification thread is started before ClientOpen is called.
*/
if (fThread.StartSync() != 0) {
jack_error("Cannot start Jack client listener");
return -1;
} else {
return 0;
}
}

void JackMachClientChannel::Stop()
{
jack_log("JackMachClientChannel::Stop");
fThread.Kill();
}

void JackMachClientChannel::ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
{
kern_return_t res = rpc_jack_client_check(fServerPort.GetPort(), (char*)name, name_res, protocol, options, status, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ClientCheck err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
{
kern_return_t res = rpc_jack_client_open(fServerPort.GetPort(), (char*)name, pid, &fPrivatePort, shared_engine, shared_client, shared_graph, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ClientOpen err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::ClientClose(int refnum, int* result)
{
kern_return_t res = rpc_jack_client_close(fPrivatePort, refnum, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ClientClose err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::ClientActivate(int refnum, int is_real_time, int* result)
{
kern_return_t res = rpc_jack_client_activate(fPrivatePort, refnum, is_real_time, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ClientActivate err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::ClientDeactivate(int refnum, int* result)
{
kern_return_t res = rpc_jack_client_deactivate(fPrivatePort, refnum, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ClientDeactivate err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortRegister(int refnum, const char* name, const char* type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result)
{
kern_return_t res = rpc_jack_port_register(fPrivatePort, refnum, (char*)name, (char*)type, flags, buffer_size, port_index, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortRegister err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortUnRegister(int refnum, jack_port_id_t port_index, int* result)
{
kern_return_t res = rpc_jack_port_unregister(fPrivatePort, refnum, port_index, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortUnRegister err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortConnect(int refnum, const char* src, const char* dst, int* result)
{
kern_return_t res = rpc_jack_port_connect_name(fPrivatePort, refnum, (char*)src, (char*)dst, result);
if (res != KERN_SUCCESS) {
jack_error("JackMachClientChannel::PortConnect err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortDisconnect(int refnum, const char* src, const char* dst, int* result)
{
kern_return_t res = rpc_jack_port_disconnect_name(fPrivatePort, refnum, (char*)src, (char*)dst, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortDisconnect err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
{
kern_return_t res = rpc_jack_port_connect(fPrivatePort, refnum, src, dst, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortConnect err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
{
kern_return_t res = rpc_jack_port_disconnect(fPrivatePort, refnum, src, dst, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortDisconnect err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
{
kern_return_t res = rpc_jack_port_rename(fPrivatePort, refnum, port, (char*)name, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::PortRename err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
{
kern_return_t res = rpc_jack_set_buffer_size(fPrivatePort, buffer_size, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::SetBufferSize err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::SetFreewheel(int onoff, int* result)
{
kern_return_t res = rpc_jack_set_freewheel(fPrivatePort, onoff, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::SetFreewheel err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char *path, jack_session_command_t **result)
{
// dunno, how to generate this rpc stuff.
#if 0
kern_return_t res = rpc_jack_session_notify(fPrivatePort, target, type, path, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::SetFreewheel err = %s", mach_error_string(res));
}
#else
*result = NULL;
#endif
}

void JackMachClientChannel::ReleaseTimebase(int refnum, int* result)
{
kern_return_t res = rpc_jack_release_timebase(fPrivatePort, refnum, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::ReleaseTimebase err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::SetTimebaseCallback(int refnum, int conditional, int* result)
{
kern_return_t res = rpc_jack_set_timebase_callback(fPrivatePort, refnum, conditional, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::SetTimebaseCallback err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::GetInternalClientName(int refnum, int int_ref, char* name_res, int* result)
{
kern_return_t res = rpc_jack_get_internal_clientname(fPrivatePort, refnum, int_ref, name_res, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::GetInternalClientName err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result)
{
kern_return_t res = rpc_jack_internal_clienthandle(fPrivatePort, refnum, (char*)client_name, status, int_ref, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::InternalClientHandle err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
{
const char* int_client_name = (client_name) ? client_name : "";
const char* int_so_name = (so_name) ? so_name : "";
const char* int_objet_data = (objet_data) ? objet_data : "";
kern_return_t res = rpc_jack_internal_clientload(fPrivatePort, refnum, (char*)int_client_name, (char*)int_so_name, (char*)int_objet_data, options, status, int_ref, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::InternalClientLoad err = %s", mach_error_string(res));
}
}

void JackMachClientChannel::InternalClientUnload(int refnum, int int_ref, int* status, int* result)
{
kern_return_t res = rpc_jack_internal_clientunload(fPrivatePort, refnum, int_ref, status, result);
if (res != KERN_SUCCESS) {
*result = -1;
jack_error("JackMachClientChannel::InternalClientUnload err = %s", mach_error_string(res));
}
}

bool JackMachClientChannel::Init()
{
jack_log("JackMachClientChannel::Init");
JackClient* client = gClientTable[fClientPort.GetPort()];
return client->Init();
}

bool JackMachClientChannel::Execute()
{
kern_return_t res;
if ((res = mach_msg_server(JackRPCClient_server, 1024, fClientPort.GetPort(), 0)) != KERN_SUCCESS) {
jack_error("JackMachClientChannel::Execute err = %s", mach_error_string(res));
JackClient* client = gClientTable[fClientPort.GetPort()];
client->ShutDown();
return false;
} else {
return true;
}
}

} // end of namespace



+ 0
- 99
macosx/JackMachClientChannel.h View File

@@ -1,99 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#ifndef __JackMachClientChannel__
#define __JackMachClientChannel__

#include "JackChannel.h"
#include "JackMachPort.h"
#include "JackPlatformPlug.h"
#include <map>

namespace Jack
{

/*!
\brief JackClientChannel using Mach IPC.
*/

class JackMachClientChannel : public detail::JackClientChannelInterface, public JackRunnableInterface
{

private:

JackMachPort fClientPort; /*! Mach port to communicate with the server : from server to client */
JackMachPort fServerPort; /*! Mach port to communicate with the server : from client to server */
mach_port_t fPrivatePort;
JackThread fThread; /*! Thread to execute the event loop */

public:

JackMachClientChannel();
~JackMachClientChannel();

int Open(const char* server_name, const char* name, char* name_res, JackClient* client, jack_options_t options, jack_status_t* status);
void Close();

int Start();
void Stop();

int ServerCheck(const char* server_name);

void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result);
void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
{}
void ClientClose(int refnum, int* result);

void ClientActivate(int refnum, int is_real_time, int* result);
void ClientDeactivate(int refnum, int* result);

void PortRegister(int refnum, const char* name, const char* type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result);
void PortUnRegister(int refnum, jack_port_id_t port_index, int* result);

void PortConnect(int refnum, const char* src, const char* dst, int* result);
void PortDisconnect(int refnum, const char* src, const char* dst, int* result);

void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);

void SetBufferSize(jack_nframes_t buffer_size, int* result);
void SetFreewheel(int onoff, int* result);

void ReleaseTimebase(int refnum, int* result);
void SetTimebaseCallback(int refnum, int conditional, int* result);

void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result);
void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result);
void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result);
void InternalClientUnload(int refnum, int int_ref, int* status, int* result);

// JackRunnableInterface interface
bool Init();
bool Execute();
};

extern std::map<mach_port_t, JackClient*> gClientTable;

} // end of namespace

#endif


+ 0
- 67
macosx/JackMachNotifyChannel.cpp View File

@@ -1,67 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackMachNotifyChannel.h"
#include "JackRPCClient.h"
#include "JackError.h"
#include "JackConstants.h"
#include <stdio.h>

namespace Jack
{

// Server side : server to client

int JackMachNotifyChannel::Open(const char* name)
{
jack_log("JackMachNotifyChannel::Open name = %s", name);

char buf[256];
snprintf(buf, sizeof(buf) - 1, "%s:%s", jack_client_entry, name);

// Connect to client notification port using client name
if (!fClientPort.ConnectPort(buf)) {
jack_error("Cannot connect client port");
return -1;
} else {
return 0;
}
}

void JackMachNotifyChannel::Close()
{
fClientPort.DisconnectPort();
}

void JackMachNotifyChannel::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2, int* result)
{
kern_return_t res = (sync)
? rpc_jack_client_sync_notify(fClientPort.GetPort(), refnum, (char*)name, notify, (char*)message, value1, value2, result)
: rpc_jack_client_async_notify(fClientPort.GetPort(), refnum, (char*)name, notify, (char*)message, value1, value2);
if (res == KERN_SUCCESS) {
*result = 0;
} else {
jack_error("JackMachNotifyChannel::ClientNotify: name = %s notify = %ld err = %s", name, notify, mach_error_string(res));
*result = -1;
}
}

} // end of namespace



+ 0
- 53
macosx/JackMachNotifyChannel.h View File

@@ -1,53 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#ifndef __JackMachNotifyChannel__
#define __JackMachNotifyChannel__

#include "JackMachPort.h"

namespace Jack
{

/*!
\brief JackNotifyChannel using Mach IPC.
*/

class JackMachNotifyChannel
{

private:

JackMachPort fClientPort; /*! Mach port to communicate with the client : from server to client */

public:

JackMachNotifyChannel()
{}

int Open(const char* name); // Open the Server/Client connection
void Close(); // Close the Server/Client connection

void ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2, int* result);
};

} // end of namespace

#endif


+ 0
- 295
macosx/JackMachPort.cpp View File

@@ -1,295 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackMachPort.h"
#include "JackError.h"

namespace Jack
{

// Server side : port is published to be accessible from other processes (clients)

bool JackMachPort::AllocatePort(const char* name, int queue)
{
mach_port_t task = mach_task_self();
kern_return_t res;

if ((res = task_get_bootstrap_port(task, &fBootPort)) != KERN_SUCCESS) {
jack_error("AllocatePort: Can't find bootstrap mach port err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &fServerPort)) != KERN_SUCCESS) {
jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_insert_right(task, fServerPort, fServerPort, MACH_MSG_TYPE_MAKE_SEND)) != KERN_SUCCESS) {
jack_error("AllocatePort: error inserting mach rights err = %s", mach_error_string(res));
return false;
}

if ((res = bootstrap_register(fBootPort, (char*)name, fServerPort)) != KERN_SUCCESS) {
jack_error("Allocate: can't check in mach port name = %s err = %s", name, mach_error_string(res));
return false;
}

mach_port_limits_t qlimits;
mach_msg_type_number_t info_cnt = MACH_PORT_LIMITS_INFO_COUNT;
if ((res = mach_port_get_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, &info_cnt)) != KERN_SUCCESS) {
jack_error("Allocate: mach_port_get_attributes error err = %s", name, mach_error_string(res));
}

jack_log("AllocatePort: queue limit %ld", qlimits.mpl_qlimit);

if (queue > 0) {
qlimits.mpl_qlimit = queue;
if ((res = mach_port_set_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, MACH_PORT_LIMITS_INFO_COUNT)) != KERN_SUCCESS) {
jack_error("Allocate: mach_port_set_attributes error name = %s err = %s", name, mach_error_string(res));
}
}

return true;
}

// Server side : port is published to be accessible from other processes (clients)

bool JackMachPort::AllocatePort(const char* name)
{
return AllocatePort(name, -1);
}

// Client side : get the published port from server

bool JackMachPort::ConnectPort(const char* name)
{
kern_return_t res;

jack_log("JackMachPort::ConnectPort %s", name);

if ((res = task_get_bootstrap_port(mach_task_self(), &fBootPort)) != KERN_SUCCESS) {
jack_error("ConnectPort: can't find bootstrap port err = %s", mach_error_string(res));
return false;
}

if ((res = bootstrap_look_up(fBootPort, (char*)name, &fServerPort)) != KERN_SUCCESS) {
jack_error("ConnectPort: can't find mach server port name = %s err = %s", name, mach_error_string(res));
return false;
}

return true;
}

bool JackMachPort::DisconnectPort()
{
jack_log("JackMacRPC::DisconnectPort");
kern_return_t res;
mach_port_t task = mach_task_self();

if (fBootPort != 0) {
if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
}
}

if (fServerPort != 0) {
if ((res = mach_port_deallocate(task, fServerPort)) != KERN_SUCCESS) {
jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fServerPort err = %s", mach_error_string(res));
}
}
return true;
}

bool JackMachPort::DestroyPort()
{
jack_log("JackMacRPC::DisconnectPort");
kern_return_t res;
mach_port_t task = mach_task_self();

if (fBootPort != 0) {
if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
jack_error("JackMacRPC::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
}
}

if (fServerPort != 0) {
if ((res = mach_port_destroy(task, fServerPort)) != KERN_SUCCESS) {
jack_error("JackMacRPC::DisconnectPort mach_port_destroy fServerPort err = %s", mach_error_string(res));
}
}

return true;
}

mach_port_t JackMachPort::GetPort()
{
return fServerPort;
}

bool JackMachPortSet::AllocatePort(const char* name, int queue)
{
kern_return_t res;
mach_port_t task = mach_task_self();

jack_log("JackMachPortSet::AllocatePort");

if ((res = task_get_bootstrap_port(task, &fBootPort)) != KERN_SUCCESS) {
jack_error("AllocatePort: Can't find bootstrap mach port err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &fServerPort)) != KERN_SUCCESS) {
jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_insert_right(task, fServerPort, fServerPort, MACH_MSG_TYPE_MAKE_SEND)) != KERN_SUCCESS) {
jack_error("AllocatePort: error inserting mach rights err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_PORT_SET, &fPortSet)) != KERN_SUCCESS) {
jack_error("AllocatePort: can't allocate mach port err = %s", mach_error_string(res));
return false;
}

if ((res = mach_port_move_member(task, fServerPort, fPortSet)) != KERN_SUCCESS) {
jack_error("AllocatePort: error in mach_port_move_member err = %s", mach_error_string(res));
return false;
}

if ((res = bootstrap_register(fBootPort, (char*)name, fServerPort)) != KERN_SUCCESS) {
jack_error("Allocate: can't check in mach port name = %s err = %s", name, mach_error_string(res));
return false;
}

mach_port_limits_t qlimits;
mach_msg_type_number_t info_cnt = MACH_PORT_LIMITS_INFO_COUNT;
if ((res = mach_port_get_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, &info_cnt)) != KERN_SUCCESS) {
jack_error("Allocate: mach_port_get_attributes error name = %s err = %s", name, mach_error_string(res));
}

jack_log("AllocatePort: queue limit = %ld", qlimits.mpl_qlimit);

if (queue > 0) {
qlimits.mpl_qlimit = queue;

if ((res = mach_port_set_attributes(task, fServerPort, MACH_PORT_LIMITS_INFO, (mach_port_info_t) & qlimits, MACH_PORT_LIMITS_INFO_COUNT)) != KERN_SUCCESS) {
jack_error("Allocate: mach_port_set_attributes error name = %s err = %s", name, mach_error_string(res));
}
}

return true;
}

// Server side : port is published to be accessible from other processes (clients)

bool JackMachPortSet::AllocatePort(const char* name)
{
return AllocatePort(name, -1);
}

bool JackMachPortSet::DisconnectPort()
{
kern_return_t res;
mach_port_t task = mach_task_self();

jack_log("JackMachPortSet::DisconnectPort");

if (fBootPort != 0) {
if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate fBootPort err = %s", mach_error_string(res));
}
}

if (fServerPort != 0) {
if ((res = mach_port_deallocate(task, fServerPort)) != KERN_SUCCESS) {
jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate fServerPort err = %s", mach_error_string(res));
}
}

return true;
}

bool JackMachPortSet::DestroyPort()
{
kern_return_t res;
mach_port_t task = mach_task_self();

jack_log("JackMachPortSet::DisconnectPort");

if (fBootPort != 0) {
if ((res = mach_port_deallocate(task, fBootPort)) != KERN_SUCCESS) {
jack_error("JackMachPortSet::DisconnectPort mach_port_deallocate err = %s", mach_error_string(res));
}
}

if (fServerPort != 0) {
if ((res = mach_port_destroy(task, fServerPort)) != KERN_SUCCESS) {
jack_error("JackMachPortSet::DisconnectPort mach_port_destroy fServerPort err = %s", mach_error_string(res));
}
}

return true;
}

mach_port_t JackMachPortSet::GetPortSet()
{
return fPortSet;
}

mach_port_t JackMachPortSet::AddPort()
{
kern_return_t res;
mach_port_t task = mach_task_self();
mach_port_t old_port, result = 0;

jack_log("JackMachPortSet::AddPort");

if ((res = mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE, &result)) != KERN_SUCCESS) {
jack_error("AddPort: can't allocate mach port err = %s", mach_error_string(res));
goto error;
}

if ((res = mach_port_request_notification(task, result, MACH_NOTIFY_NO_SENDERS,
1, result, MACH_MSG_TYPE_MAKE_SEND_ONCE, &old_port)) != KERN_SUCCESS) {
jack_error("AddPort: error in mach_port_request_notification err = %s", mach_error_string(res));
goto error;
}

if ((res = mach_port_move_member(task, result, fPortSet)) != KERN_SUCCESS) {
jack_error("AddPort: error in mach_port_move_member err = %s", mach_error_string(res));
goto error;
}

return result;

error:
if (result) {
if ((res = mach_port_destroy(task, result)) != KERN_SUCCESS) {
jack_error("JackMacRPC::DisconnectPort mach_port_destroy err = %s", mach_error_string(res));
}
}
return 0;
}


} // end of namespace


+ 0
- 88
macosx/JackMachPort.h View File

@@ -1,88 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#ifndef __JackMachPort__
#define __JackMachPort__

#include <mach/mach.h>
#include <mach/mach_types.h>
#include <mach/message.h>
#include <mach/mach_error.h>
#include <servers/bootstrap.h>

namespace Jack
{

/*!
\brief Mach port.
*/

class JackMachPort
{

protected:

mach_port_t fBootPort;
mach_port_t fServerPort;

public:

JackMachPort():fBootPort(0), fServerPort(0)
{}
virtual ~JackMachPort()
{}

virtual bool AllocatePort(const char* name);
virtual bool AllocatePort(const char* name, int queue);
virtual bool ConnectPort(const char* name);
virtual bool DisconnectPort();
virtual bool DestroyPort();
virtual mach_port_t GetPort();
};

/*!
\brief Mach port set.
*/

class JackMachPortSet : public JackMachPort
{

private:

mach_port_t fPortSet;

public:

JackMachPortSet():fPortSet(0)
{}
virtual ~JackMachPortSet()
{}

bool AllocatePort(const char* name);
bool AllocatePort(const char* name, int queue);
bool DisconnectPort();
bool DestroyPort();
mach_port_t GetPortSet();
mach_port_t AddPort();
};

} // end of namespace

#endif


+ 0
- 174
macosx/JackMachServerChannel.cpp View File

@@ -1,174 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackTools.h"
#include "JackMachServerChannel.h"
#include "JackRPCEngineServer.c"
#include "JackError.h"
#include "JackServer.h"
#include "JackLockedEngine.h"
#include "JackNotification.h"
#include "JackServerGlobals.h"

using namespace std;

namespace Jack
{

map<mach_port_t, JackMachServerChannel*> JackMachServerChannel::fPortTable;

JackMachServerChannel::JackMachServerChannel():fThread(this)
{}

JackMachServerChannel::~JackMachServerChannel()
{}

int JackMachServerChannel::Open(const char* server_name, JackServer* server)
{
jack_log("JackMachServerChannel::Open");
char jack_server_entry_name[512];
snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);

if (!fServerPort.AllocatePort(jack_server_entry_name, 16)) { // 16 is the max possible value
jack_error("Cannot check in Jack server");
return -1;
}

fServer = server;
fPortTable[fServerPort.GetPort()] = this;
return 0;
}

void JackMachServerChannel::Close()
{
jack_log("JackMachServerChannel::Close");
#ifdef MAC_OS_X_VERSION_10_5
// Exception does not work in this case on pre Snow Loopard systems, see JackMachServerNotifyChannel::NotifyQuit()
fThread.Kill();
#else
fThread.Stop();
#endif
fServerPort.DestroyPort();
}
int JackMachServerChannel::Start()
{
if (fThread.Start() != 0) {
jack_error("Cannot start Jack server listener");
return -1;
}
return 0;
}

JackLockedEngine* JackMachServerChannel::GetEngine()
{
return fServer->GetEngine();
}

JackServer* JackMachServerChannel::GetServer()
{
return fServer;
}

void JackMachServerChannel::ClientCheck(char* name, char* name_res, int protocol, int options, int* status, int* result)
{
*result = GetEngine()->ClientCheck(name, name_res, protocol, options, status);
}

void JackMachServerChannel::ClientOpen(char* name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result)
{
int refnum = -1;
*result = GetEngine()->ClientExternalOpen(name, pid, &refnum, shared_engine, shared_client, shared_graph);

if (*result == 0) {
mach_port_t port = fServerPort.AddPort();
if (port != 0) {
fClientTable[port] = refnum;
fPortTable[port] = this;
*private_port = port;
} else {
jack_error("Cannot create private client mach port");
*result = -1;
}
} else {
jack_error("Cannot create new client");
}
}

void JackMachServerChannel::ClientClose(mach_port_t private_port, int refnum)
{
GetEngine()->ClientExternalClose(refnum);
fClientTable.erase(private_port);

// Hum, hum....
kern_return_t res;
if ((res = mach_port_destroy(mach_task_self(), private_port)) != KERN_SUCCESS) {
jack_error("server_rpc_jack_client_close mach_port_destroy %s", mach_error_string(res));
}
}

void JackMachServerChannel::ClientKill(mach_port_t private_port)
{
jack_log("JackMachServerChannel::ClientKill");
int refnum = fClientTable[private_port];
assert(refnum > 0);
fServer->ClientKill(refnum);
fClientTable.erase(private_port);

// Hum, hum....
kern_return_t res;
if ((res = mach_port_destroy(mach_task_self(), private_port)) != KERN_SUCCESS) {
jack_error("server_rpc_jack_client_close mach_port_destroy %s", mach_error_string(res));
}
}

boolean_t JackMachServerChannel::MessageHandler(mach_msg_header_t* Request, mach_msg_header_t* Reply)
{
if (Request->msgh_id == MACH_NOTIFY_NO_SENDERS) {
jack_log("MACH_NOTIFY_NO_SENDERS %ld", Request->msgh_local_port);
JackMachServerChannel* channel = JackMachServerChannel::fPortTable[Request->msgh_local_port];
assert(channel);
channel->ClientKill(Request->msgh_local_port);
} else {
JackRPCEngine_server(Request, Reply);
}
return true;
}

bool JackMachServerChannel::Execute()
{
try {
kern_return_t res;
if ((res = mach_msg_server(MessageHandler, 1024, fServerPort.GetPortSet(), 0)) != KERN_SUCCESS) {
jack_log("JackMachServerChannel::Execute: err = %s", mach_error_string(res));
// A recoverable error, so keep running...
}
return true;
} catch (JackQuitException& e) {
jack_log("JackMachServerChannel::Execute JackQuitException");
return false;
}
}

} // end of namespace



+ 0
- 76
macosx/JackMachServerChannel.h View File

@@ -1,76 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#ifndef __JackMachServerChannel__
#define __JackMachServerChannel__

#include "JackPlatformPlug.h"
#include "JackMachPort.h"
#include <map>

namespace Jack
{

class JackServer;
class JackLockedEngine;

/*!
\brief JackServerChannel using Mach IPC.
*/

class JackMachServerChannel : public JackRunnableInterface
{

private:

JackMachPortSet fServerPort; /*! Mach port to communicate with the server : from client to server */
JackThread fThread; /*! Thread to execute the event loop */
JackServer* fServer;
std::map<mach_port_t, int> fClientTable;

static boolean_t MessageHandler(mach_msg_header_t* Request, mach_msg_header_t* Reply);

public:

JackMachServerChannel();
~JackMachServerChannel();

int Open(const char* server_name, JackServer* server); // Open the Server/Client connection
void Close(); // Close the Server/Client connection
int Start();
JackLockedEngine* GetEngine();
JackServer* GetServer();

void ClientCheck(char* name, char* name_res, int protocol, int options, int* status, int* result);
void ClientOpen(char* name, int pid, mach_port_t* private_port, int* shared_engine, int* shared_client, int* shared_graph, int* result);
void ClientClose(mach_port_t private_port, int refnum);
void ClientKill(mach_port_t private_port);

bool Execute();

// Has to be public..
static std::map<mach_port_t, JackMachServerChannel*> fPortTable;
};

} // end of namespace

#endif


+ 0
- 70
macosx/JackMachServerNotifyChannel.cpp View File

@@ -1,70 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#include "JackMachServerNotifyChannel.h"
#include "JackRPCEngineUser.c"
#include "JackNotification.h"
#include "JackTools.h"
#include "JackConstants.h"
#include "JackError.h"
#include <stdio.h>

namespace Jack
{

int JackMachServerNotifyChannel::Open(const char* server_name)
{
jack_log("JackMachServerChannel::Open");
char jack_server_entry_name[512];
snprintf(jack_server_entry_name, sizeof(jack_server_entry_name), "%s.%d_%s", jack_server_entry, JackTools::GetUID(), server_name);

if (!fClientPort.ConnectPort(jack_server_entry_name)) {
jack_error("Cannot connect to server port");
return -1;
} else {
return 0;
}
}

void JackMachServerNotifyChannel::Close()
{}

void JackMachServerNotifyChannel::Notify(int refnum, int notify, int value)
{
kern_return_t res = rpc_jack_client_rt_notify(fClientPort.GetPort(), refnum, notify, value, 0);
if (res != KERN_SUCCESS) {
jack_error("Could not write request ref = %d notify = %d err = %s", refnum, notify, mach_error_string(res));
}
}
void JackMachServerNotifyChannel::NotifyQuit()
{
#ifdef MAC_OS_X_VERSION_10_5
// Nothing : since exception does not work in this case on pre Snow Loopard systems, see JackMachServerChannel::Close()
#else
kern_return_t res = rpc_jack_client_rt_notify(fClientPort.GetPort(), -1, kQUIT, 0, 0);
if (res != KERN_SUCCESS) {
jack_error("Could not write request ref = %d notify = %d err = %s", -1, kQUIT, mach_error_string(res));
}
#endif
}

} // end of namespace



+ 0
- 55
macosx/JackMachServerNotifyChannel.h View File

@@ -1,55 +0,0 @@
/*
Copyright (C) 2004-2008 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

#ifndef __JackMachServerNotifyChannel__
#define __JackMachServerNotifyChannel__

#include "JackChannel.h"
#include "JackMachPort.h"

namespace Jack
{

/*!
\brief JackServerNotifyChannel using Mach IPC.
*/

class JackMachServerNotifyChannel
{

private:

JackMachPort fClientPort; /*! Mach port to communicate with the server : from client to server */

public:

JackMachServerNotifyChannel()
{}

int Open(const char* server_name); // Open the Server/Client connection
void Close(); // Close the Server/Client connection

void Notify(int refnum, int notify, int value);
void NotifyQuit();
};

} // end of namespace

#endif


+ 0
- 25
macosx/JackPlatformPlug_os.h View File

@@ -33,13 +33,6 @@ namespace Jack
class JackMachThread;
class JackMachSemaphore;
/*
class JackMachServerChannel;
class JackMachClientChannel;
class JackMachServerNotifyChannel;
class JackMachNotifyChannel;
*/
class JackSocketServerChannel;
class JackSocketClientChannel;
class JackSocketServerNotifyChannel;
@@ -67,22 +60,6 @@ namespace Jack { typedef JackClientSocket JackChannelTransaction; }
#include "JackProcessSync.h"
/* Only on windows a special JackProcessSync is used. It is directly defined by including JackProcessSync.h here */

/* __JackPlatformServerChannel__ */
//#include "JackMachServerChannel.h"
//namespace Jack { typedef JackMachServerChannel JackServerChannel; }

/* __JackPlatformClientChannel__ */
//#include "JackMachClientChannel.h"
//namespace Jack { typedef JackMachClientChannel JackClientChannel; }

/* __JackPlatformServerNotifyChannel__ */
//#include "JackMachServerNotifyChannel.h"
//namespace Jack { typedef JackMachServerNotifyChannel JackServerNotifyChannel; }

/* __JackPlatformNotifyChannel__ */
//#include "JackMachNotifyChannel.h"
//namespace Jack { typedef JackMachNotifyChannel JackNotifyChannel; }

/* __JackPlatformServerChannel__ */
#include "JackSocketServerChannel.h"
namespace Jack { typedef JackSocketServerChannel JackServerChannel; }
@@ -99,8 +76,6 @@ namespace Jack { typedef JackSocketServerNotifyChannel JackServerNotifyChannel;
#include "JackSocketNotifyChannel.h"
namespace Jack { typedef JackSocketNotifyChannel JackNotifyChannel; }



/* __JackPlatformNetSocket__ */
#include "JackNetUnixSocket.h"
namespace Jack { typedef JackNetUnixSocket JackNetSocket; }


+ 0
- 128
macosx/Jackdmp.xcodeproj/project.pbxproj View File

@@ -132,7 +132,6 @@
4B32258010A3195A00838A8E /* netjack_packet.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B3224ED10A315C400838A8E /* netjack_packet.h */; };
4B32258110A3195B00838A8E /* netsource.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B32256310A318E300838A8E /* netsource.c */; };
4B35C41E0D4731D1000DE7AE /* Jackdmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2250834F06A00C94B91 /* Jackdmp.cpp */; };
4B35C4290D4731D1000DE7AE /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4B35C42A0D4731D1000DE7AE /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
4B35C42B0D4731D1000DE7AE /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
4B35C42C0D4731D1000DE7AE /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
@@ -169,8 +168,6 @@
4B35C4530D4731D1000DE7AE /* JackMidiPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B80D7E50BA0D17400F035BB /* JackMidiPort.h */; };
4B35C4540D4731D1000DE7AE /* midiport.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B6B9EF50CD0958B0051EE5A /* midiport.h */; settings = {ATTRIBUTES = (Public, ); }; };
4B35C4550D4731D1000DE7AE /* JackTools.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BE4CC000CDA153400CCF5BB /* JackTools.h */; };
4B35C4590D4731D1000DE7AE /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
4B35C45A0D4731D1000DE7AE /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4B35C45B0D4731D1000DE7AE /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4B35C45C0D4731D1000DE7AE /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4B35C45E0D4731D1000DE7AE /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -239,7 +236,6 @@
4B35C4BF0D4731D1000DE7AE /* midiport.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B6B9EF50CD0958B0051EE5A /* midiport.h */; settings = {ATTRIBUTES = (Public, ); }; };
4B35C4C00D4731D1000DE7AE /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
4B35C4C10D4731D1000DE7AE /* JackTools.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BE4CC000CDA153400CCF5BB /* JackTools.h */; };
4B35C4C40D4731D1000DE7AE /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4B35C4C50D4731D1000DE7AE /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4B35C4C60D4731D1000DE7AE /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4B35C4C80D4731D1000DE7AE /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -261,7 +257,6 @@
4B35C4DD0D4731D1000DE7AE /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
4B35C4DE0D4731D1000DE7AE /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
4B35C4DF0D4731D1000DE7AE /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
4B35C4E00D4731D1000DE7AE /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
4B35C4E20D4731D1000DE7AE /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
4B35C4EB0D4731D1000DE7AE /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; };
4B35C4EC0D4731D1000DE7AE /* JackServerAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F50834EFB000C94B91 /* JackServerAPI.cpp */; };
@@ -311,7 +306,6 @@
4B43A8CB1014605000E52943 /* JackLoopbackDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B43A8C91014605000E52943 /* JackLoopbackDriver.h */; };
4B43A8DF1014615800E52943 /* JackLoopbackDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B43A8C91014605000E52943 /* JackLoopbackDriver.h */; };
4B43A8E11014615800E52943 /* JackLoopbackDriver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B43A8C81014605000E52943 /* JackLoopbackDriver.cpp */; };
4B47AC8210B5890100469C67 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4B47AC8310B5890100469C67 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
4B47AC8410B5890100469C67 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
4B47AC8510B5890100469C67 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
@@ -332,7 +326,6 @@
4B47AC9410B5890100469C67 /* JackMachSemaphore.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF6C1D608ACE64C001E2013 /* JackMachSemaphore.h */; };
4B47AC9510B5890100469C67 /* JackGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB73F608AD291A00DB99B8 /* JackGlobals.h */; };
4B47AC9610B5890100469C67 /* JackMachThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */; };
4B47AC9710B5890100469C67 /* JackMachClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298708AF450200D450D4 /* JackMachClientChannel.h */; };
4B47AC9810B5890100469C67 /* JackSynchro.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD561C708EEB910006BBC2A /* JackSynchro.h */; };
4B47AC9910B5890100469C67 /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
4B47AC9A10B5890100469C67 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
@@ -353,9 +346,6 @@
4B47ACA910B5890100469C67 /* JackMessageBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B4F9C8B0DC20C0400706CB0 /* JackMessageBuffer.h */; };
4B47ACAA10B5890100469C67 /* JackPosixThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6A30E703B2E0066E42F /* JackPosixThread.h */; };
4B47ACAB10B5890100469C67 /* JackProcessSync.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BECB2F40F4451C10091B70A /* JackProcessSync.h */; };
4B47ACAE10B5890100469C67 /* JackMacLibClientRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */; };
4B47ACAF10B5890100469C67 /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
4B47ACB010B5890100469C67 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4B47ACB110B5890100469C67 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4B47ACB210B5890100469C67 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4B47ACB310B5890100469C67 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -369,7 +359,6 @@
4B47ACBB10B5890100469C67 /* JackFrameTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8FB0D08AC88EF00D1A344 /* JackFrameTimer.cpp */; };
4B47ACBC10B5890100469C67 /* JackMachSemaphore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF6C1D508ACE64C001E2013 /* JackMachSemaphore.cpp */; };
4B47ACBD10B5890100469C67 /* JackMachThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */; };
4B47ACBE10B5890100469C67 /* JackMachClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */; };
4B47ACBF10B5890100469C67 /* JackGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2C28F908DAD01E00249230 /* JackGlobals.cpp */; };
4B47ACC010B5890100469C67 /* ringbuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B003AB008E2B2BA0060EFDC /* ringbuffer.c */; };
4B47ACC110B5890100469C67 /* JackDebugClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B98AE000931D30C0091932A /* JackDebugClient.cpp */; };
@@ -423,7 +412,6 @@
4B60CE490AAABA31004956AA /* connect.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B60CE480AAABA31004956AA /* connect.c */; };
4B60CE4A0AAABA31004956AA /* connect.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B60CE480AAABA31004956AA /* connect.c */; };
4B699BAA097D421600A18468 /* Jackdmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2250834F06A00C94B91 /* Jackdmp.cpp */; };
4B699C02097D421600A18468 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4B699C03097D421600A18468 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
4B699C04097D421600A18468 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
4B699C05097D421600A18468 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
@@ -444,13 +432,9 @@
4B699C16097D421600A18468 /* JackMachSemaphore.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF6C1D608ACE64C001E2013 /* JackMachSemaphore.h */; };
4B699C17097D421600A18468 /* JackGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB73F608AD291A00DB99B8 /* JackGlobals.h */; };
4B699C18097D421600A18468 /* JackMachThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */; };
4B699C19097D421600A18468 /* JackMachClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298708AF450200D450D4 /* JackMachClientChannel.h */; };
4B699C20097D421600A18468 /* JackSynchro.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD561C708EEB910006BBC2A /* JackSynchro.h */; };
4B699C21097D421600A18468 /* JackDebugClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B98AE010931D30C0091932A /* JackDebugClient.h */; };
4B699C22097D421600A18468 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
4B699C25097D421600A18468 /* JackMacLibClientRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */; };
4B699C26097D421600A18468 /* JackRPCEngineUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B769076B74D200D170DE /* JackRPCEngineUser.c */; };
4B699C27097D421600A18468 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4B699C28097D421600A18468 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4B699C29097D421600A18468 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4B699C2B097D421600A18468 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -464,11 +448,9 @@
4B699C33097D421600A18468 /* JackFrameTimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8FB0D08AC88EF00D1A344 /* JackFrameTimer.cpp */; };
4B699C35097D421600A18468 /* JackMachSemaphore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF6C1D508ACE64C001E2013 /* JackMachSemaphore.cpp */; };
4B699C36097D421600A18468 /* JackMachThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */; };
4B699C37097D421600A18468 /* JackMachClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */; };
4B699C3D097D421600A18468 /* JackGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2C28F908DAD01E00249230 /* JackGlobals.cpp */; };
4B699C3F097D421600A18468 /* ringbuffer.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B003AB008E2B2BA0060EFDC /* ringbuffer.c */; };
4B699C40097D421600A18468 /* JackDebugClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B98AE000931D30C0091932A /* JackDebugClient.cpp */; };
4B699C4E097D421600A18468 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4B699C4F097D421600A18468 /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
4B699C50097D421600A18468 /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
4B699C51097D421600A18468 /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
@@ -497,11 +479,7 @@
4B699C71097D421600A18468 /* JackEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2130834F02800C94B91 /* JackEngine.h */; };
4B699C73097D421600A18468 /* JackExternalClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1F70834EFBD00C94B91 /* JackExternalClient.h */; };
4B699C74097D421600A18468 /* JackServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2220834F05C00C94B91 /* JackServer.h */; };
4B699C77097D421600A18468 /* JackMachNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */; };
4B699C78097D421600A18468 /* JackMachServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */; };
4B699C79097D421600A18468 /* JackMachServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */; };
4B699C7B097D421600A18468 /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
4B699C7E097D421600A18468 /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4B699C7F097D421600A18468 /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4B699C80097D421600A18468 /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4B699C82097D421600A18468 /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -523,12 +501,7 @@
4B699C97097D421600A18468 /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
4B699C99097D421600A18468 /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
4B699C9A097D421600A18468 /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
4B699C9B097D421600A18468 /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
4B699C9D097D421600A18468 /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
4B699CA1097D421600A18468 /* JackMacEngineRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */; };
4B699CA2097D421600A18468 /* JackMachNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */; };
4B699CA3097D421600A18468 /* JackMachServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */; };
4B699CA4097D421600A18468 /* JackMachServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */; };
4B699CB4097D421600A18468 /* metro.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D16B0834EDF000C94B91 /* metro.c */; };
4B699CC4097D421600A18468 /* lsp.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1690834EDE600C94B91 /* lsp.c */; };
4B699CF6097D421600A18468 /* freewheel.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1710834EE0F00C94B91 /* freewheel.c */; };
@@ -585,7 +558,6 @@
4B8A38F1117B827E00664E07 /* JackSocketClientChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6AF0E703B8D0066E42F /* JackSocketClientChannel.cpp */; };
4B8A38F6117B82AB00664E07 /* JackSocket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6AD0E703B8D0066E42F /* JackSocket.cpp */; };
4B8A38F7117B82B200664E07 /* JackSocketClientChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6B00E703B8D0066E42F /* JackSocketClientChannel.h */; };
4B8A390D117B852E00664E07 /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4B93F1990E87992100E4ECCD /* JackPosixThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3B6A20E703B2E0066E42F /* JackPosixThread.cpp */; };
4B93F19A0E87992200E4ECCD /* JackPosixThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC3B6A30E703B2E0066E42F /* JackPosixThread.h */; };
4B93F19C0E87998200E4ECCD /* JackPosixServerLaunch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF5FBBA0E878B9C003D2374 /* JackPosixServerLaunch.cpp */; };
@@ -606,7 +578,6 @@
4B9A26610DBF8ADD006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
4B9A26640DBF8B14006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
4B9A26790DBF8B88006E9FBC /* JackError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B9A25B30DBF8330006E9FBC /* JackError.cpp */; };
4BA3393510B2E36800190E3B /* JackMachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B799AD707899652003F3F15 /* JackMachPort.h */; };
4BA3393610B2E36800190E3B /* JackError.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1770834EE4800C94B91 /* JackError.h */; };
4BA3393710B2E36800190E3B /* JackTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1830834EE5800C94B91 /* JackTime.h */; };
4BA3393810B2E36800190E3B /* JackShmMem.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1870834EE7900C94B91 /* JackShmMem.h */; };
@@ -635,9 +606,6 @@
4BA3394F10B2E36800190E3B /* JackEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2130834F02800C94B91 /* JackEngine.h */; };
4BA3395010B2E36800190E3B /* JackExternalClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D1F70834EFBD00C94B91 /* JackExternalClient.h */; };
4BA3395110B2E36800190E3B /* JackServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF8D2220834F05C00C94B91 /* JackServer.h */; };
4BA3395210B2E36800190E3B /* JackMachNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */; };
4BA3395310B2E36800190E3B /* JackMachServerChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */; };
4BA3395410B2E36800190E3B /* JackMachServerNotifyChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */; };
4BA3395510B2E36800190E3B /* JackConstants.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B66A8580934964500A89560 /* JackConstants.h */; };
4BA3395610B2E36800190E3B /* JackTransportEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD4B4D409BACD9600750C0F /* JackTransportEngine.h */; };
4BA3395710B2E36800190E3B /* JackServerGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC2168D0A444BED00BDA09F /* JackServerGlobals.h */; };
@@ -665,7 +633,6 @@
4BA3396D10B2E36800190E3B /* JackMidiDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF339200F8B873E0080FB5B /* JackMidiDriver.h */; };
4BA3396E10B2E36800190E3B /* JackWaitThreadedDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BBC93B90DF9736C002DF220 /* JackWaitThreadedDriver.h */; };
4BA3396F10B2E36800190E3B /* JackArgParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF284170F31B4BC00B05BE3 /* JackArgParser.h */; };
4BA3397210B2E36800190E3B /* JackMachPort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B799AD607899652003F3F15 /* JackMachPort.cpp */; };
4BA3397310B2E36800190E3B /* JackShmMem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1880834EE7900C94B91 /* JackShmMem.cpp */; };
4BA3397410B2E36800190E3B /* shm.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1900834EE8400C94B91 /* shm.c */; };
4BA3397510B2E36800190E3B /* JackActivationCount.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1A80834EEB400C94B91 /* JackActivationCount.cpp */; };
@@ -687,12 +654,7 @@
4BA3398510B2E36800190E3B /* JackEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2140834F02800C94B91 /* JackEngine.cpp */; };
4BA3398610B2E36800190E3B /* JackExternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F80834EFBD00C94B91 /* JackExternalClient.cpp */; };
4BA3398710B2E36800190E3B /* JackInternalClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1ED0834EF9200C94B91 /* JackInternalClient.cpp */; };
4BA3398810B2E36800190E3B /* JackRPCClientUser.c in Sources */ = {isa = PBXBuildFile; fileRef = 4B89B759076B731100D170DE /* JackRPCClientUser.c */; };
4BA3398910B2E36800190E3B /* JackServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D2210834F05C00C94B91 /* JackServer.cpp */; };
4BA3398A10B2E36800190E3B /* JackMacEngineRPC.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */; };
4BA3398B10B2E36800190E3B /* JackMachNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */; };
4BA3398C10B2E36800190E3B /* JackMachServerChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */; };
4BA3398D10B2E36800190E3B /* JackMachServerNotifyChannel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */; };
4BA3398E10B2E36800190E3B /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; };
4BA3398F10B2E36800190E3B /* JackServerAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F50834EFB000C94B91 /* JackServerAPI.cpp */; };
4BA3399010B2E36800190E3B /* JackServerGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC216880A444BDE00BDA09F /* JackServerGlobals.cpp */; };
@@ -1499,7 +1461,6 @@
4B37C20406DF1FBE0016E567 /* CALatencyLog.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CALatencyLog.h; path = /Developer/Examples/CoreAudio/PublicUtility/CALatencyLog.h; sourceTree = "<absolute>"; };
4B37C20906DF1FE20016E567 /* latency.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = latency.c; path = /Developer/Examples/CoreAudio/PublicUtility/latency.c; sourceTree = "<absolute>"; };
4B3F49070AD8503300491C6E /* cpu.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpu.c; path = ../tests/cpu.c; sourceTree = SOURCE_ROOT; };
4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMacEngineRPC.cpp; sourceTree = SOURCE_ROOT; };
4B43A8BA10145F6F00E52943 /* jack_loopback.so */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = jack_loopback.so; sourceTree = BUILT_PRODUCTS_DIR; };
4B43A8C81014605000E52943 /* JackLoopbackDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackLoopbackDriver.cpp; path = ../common/JackLoopbackDriver.cpp; sourceTree = SOURCE_ROOT; };
4B43A8C91014605000E52943 /* JackLoopbackDriver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackLoopbackDriver.h; path = ../common/JackLoopbackDriver.h; sourceTree = SOURCE_ROOT; };
@@ -1551,8 +1512,6 @@
4B6F7AEC0CD0CDBD00F48A9D /* JackEngineControl.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackEngineControl.cpp; path = ../common/JackEngineControl.cpp; sourceTree = SOURCE_ROOT; };
4B76C7680E5AB2DB00E2AC21 /* JackNetInterface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackNetInterface.cpp; path = ../common/JackNetInterface.cpp; sourceTree = SOURCE_ROOT; };
4B76C7690E5AB2DB00E2AC21 /* JackNetInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackNetInterface.h; path = ../common/JackNetInterface.h; sourceTree = SOURCE_ROOT; };
4B799AD607899652003F3F15 /* JackMachPort.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachPort.cpp; sourceTree = "<group>"; };
4B799AD707899652003F3F15 /* JackMachPort.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachPort.h; sourceTree = "<group>"; };
4B80D7E50BA0D17400F035BB /* JackMidiPort.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackMidiPort.h; path = ../common/JackMidiPort.h; sourceTree = SOURCE_ROOT; };
4B80D7E60BA0D17400F035BB /* JackMidiPort.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiPort.cpp; path = ../common/JackMidiPort.cpp; sourceTree = SOURCE_ROOT; };
4B80D7E70BA0D17400F035BB /* JackMidiAPI.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiAPI.cpp; path = ../common/JackMidiAPI.cpp; sourceTree = SOURCE_ROOT; };
@@ -1561,8 +1520,6 @@
4B869D7F08C9CB00001CF041 /* JackDriverLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackDriverLoader.cpp; path = ../common/JackDriverLoader.cpp; sourceTree = SOURCE_ROOT; };
4B88D03911298BEE007A87C1 /* weakjack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = weakjack.h; path = ../common/jack/weakjack.h; sourceTree = SOURCE_ROOT; };
4B88D03A11298BEE007A87C1 /* weakmacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = weakmacros.h; path = ../common/jack/weakmacros.h; sourceTree = SOURCE_ROOT; };
4B89B759076B731100D170DE /* JackRPCClientUser.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = JackRPCClientUser.c; path = RPC/JackRPCClientUser.c; sourceTree = SOURCE_ROOT; };
4B89B769076B74D200D170DE /* JackRPCEngineUser.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = JackRPCEngineUser.c; path = RPC/JackRPCEngineUser.c; sourceTree = SOURCE_ROOT; };
4B940B9B06DDDE5B00D77F60 /* AudioHardware.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = AudioHardware.h; path = /System/Library/Frameworks/CoreAudio.framework/Versions/A/Headers/AudioHardware.h; sourceTree = "<absolute>"; };
4B94334910A5E666002A187F /* systemdeps.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = systemdeps.h; path = ../common/jack/systemdeps.h; sourceTree = SOURCE_ROOT; };
4B95BCAD0D913073000F7695 /* control.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = control.h; path = ../common/jack/control.h; sourceTree = SOURCE_ROOT; };
@@ -1647,7 +1604,6 @@
4BF339150F8B86DC0080FB5B /* JackCoreMidiDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackCoreMidiDriver.cpp; path = coremidi/JackCoreMidiDriver.cpp; sourceTree = SOURCE_ROOT; };
4BF3391F0F8B873E0080FB5B /* JackMidiDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackMidiDriver.cpp; path = ../common/JackMidiDriver.cpp; sourceTree = SOURCE_ROOT; };
4BF339200F8B873E0080FB5B /* JackMidiDriver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JackMidiDriver.h; path = ../common/JackMidiDriver.h; sourceTree = SOURCE_ROOT; };
4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMacLibClientRPC.cpp; sourceTree = SOURCE_ROOT; };
4BF4BAB00E3480AB00403CDF /* JackAudioAdapterFactory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JackAudioAdapterFactory.cpp; path = ../common/JackAudioAdapterFactory.cpp; sourceTree = SOURCE_ROOT; };
4BF520520CB8D0E80037470E /* timestamps.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = timestamps.c; path = ../common/timestamps.c; sourceTree = SOURCE_ROOT; };
4BF520580CB8D1010037470E /* timestamps.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = timestamps.h; path = ../common/timestamps.h; sourceTree = SOURCE_ROOT; };
@@ -1720,14 +1676,6 @@
4BFA82CF0DF6A9E40087B4E1 /* jack_impulse_grabber */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_impulse_grabber; sourceTree = BUILT_PRODUCTS_DIR; };
4BFA99A20AAAF3B0009E916C /* jdelay */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jdelay; sourceTree = BUILT_PRODUCTS_DIR; };
4BFA99A90AAAF40C009E916C /* jdelay.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jdelay.cpp; path = ../tests/jdelay.cpp; sourceTree = SOURCE_ROOT; };
4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachServerNotifyChannel.cpp; sourceTree = "<group>"; };
4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachServerChannel.h; sourceTree = "<group>"; };
4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachServerChannel.cpp; sourceTree = "<group>"; };
4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachServerNotifyChannel.h; sourceTree = "<group>"; };
4BFB298708AF450200D450D4 /* JackMachClientChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachClientChannel.h; sourceTree = "<group>"; };
4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachNotifyChannel.cpp; sourceTree = "<group>"; };
4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachNotifyChannel.h; sourceTree = "<group>"; };
4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachClientChannel.cpp; sourceTree = SOURCE_ROOT; };
4BFB73F608AD291A00DB99B8 /* JackGlobals.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackGlobals.h; path = ../common/JackGlobals.h; sourceTree = SOURCE_ROOT; };
4BFB741E08AD2B9900DB99B8 /* JackMachThread.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackMachThread.cpp; sourceTree = SOURCE_ROOT; };
4BFB741F08AD2B9900DB99B8 /* JackMachThread.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackMachThread.h; sourceTree = SOURCE_ROOT; };
@@ -2629,24 +2577,6 @@
name = Additional;
sourceTree = "<group>";
};
4B168CA3076A5319005B2802 /* MIG_RPC */ = {
isa = PBXGroup;
children = (
4B89B759076B731100D170DE /* JackRPCClientUser.c */,
4B4259E5076B635E00C1ECE1 /* JackMacEngineRPC.cpp */,
);
name = MIG_RPC;
sourceTree = "<group>";
};
4B168CA4076A5333005B2802 /* MIG_RPC */ = {
isa = PBXGroup;
children = (
4B89B769076B74D200D170DE /* JackRPCEngineUser.c */,
4BF3937C0626BF3600CC67FA /* JackMacLibClientRPC.cpp */,
);
name = MIG_RPC;
sourceTree = "<group>";
};
4B19B3010E23629800DD4A82 /* Adapter */ = {
isa = PBXGroup;
children = (
@@ -2820,7 +2750,6 @@
4BA550F905E241D900569492 /* Library */ = {
isa = PBXGroup;
children = (
4B168CA4076A5333005B2802 /* MIG_RPC */,
4BF8D1FB0834EFD100C94B91 /* JackLibGlobals.h */,
4BF8D1FC0834EFD100C94B91 /* JackLibClient.h */,
4BF8D1FD0834EFD100C94B91 /* JackLibClient.cpp */,
@@ -2846,7 +2775,6 @@
4BA550FB05E2420000569492 /* Engine */ = {
isa = PBXGroup;
children = (
4B168CA3076A5319005B2802 /* MIG_RPC */,
4B5F253D0DEE9B8F0041E486 /* JackLockedEngine.h */,
4BF8D2130834F02800C94B91 /* JackEngine.h */,
4BF8D2140834F02800C94B91 /* JackEngine.cpp */,
@@ -2874,7 +2802,6 @@
4BB371D40C1AD85A0050C1E4 /* JackNotification.h */,
4BF8D1B30834EED500C94B91 /* JackInternalClientChannel.h */,
4BFB299908AF452300D450D4 /* Socket */,
4BFB299808AF451200D450D4 /* Mach */,
);
name = Channels;
sourceTree = "<group>";
@@ -2965,23 +2892,6 @@
name = MIDI;
sourceTree = "<group>";
};
4BFB299808AF451200D450D4 /* Mach */ = {
isa = PBXGroup;
children = (
4B799AD707899652003F3F15 /* JackMachPort.h */,
4B799AD607899652003F3F15 /* JackMachPort.cpp */,
4BFB298708AF450200D450D4 /* JackMachClientChannel.h */,
4BFB29AE08AF45FD00D450D4 /* JackMachClientChannel.cpp */,
4BFB297808AF44ED00D450D4 /* JackMachServerChannel.h */,
4BFB297908AF44ED00D450D4 /* JackMachServerChannel.cpp */,
4BFB297A08AF44ED00D450D4 /* JackMachServerNotifyChannel.h */,
4BFB297708AF44ED00D450D4 /* JackMachServerNotifyChannel.cpp */,
4BFB298908AF450200D450D4 /* JackMachNotifyChannel.h */,
4BFB298808AF450200D450D4 /* JackMachNotifyChannel.cpp */,
);
name = Mach;
sourceTree = "<group>";
};
4BFB299908AF452300D450D4 /* Socket */ = {
isa = PBXGroup;
children = (
@@ -3112,7 +3022,6 @@
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
4B35C4290D4731D1000DE7AE /* JackMachPort.h in Headers */,
4B35C42A0D4731D1000DE7AE /* JackError.h in Headers */,
4B35C42B0D4731D1000DE7AE /* JackTime.h in Headers */,
4B35C42C0D4731D1000DE7AE /* JackShmMem.h in Headers */,
@@ -3229,7 +3138,6 @@
4B8A38AD117B810A00664E07 /* JackSocketNotifyChannel.h in Headers */,
4B8A38B0117B812500664E07 /* JackSocketServerChannel.h in Headers */,
4B8A38C4117B814000664E07 /* JackSocketServerNotifyChannel.h in Headers */,
4B8A390D117B852E00664E07 /* JackMachPort.h in Headers */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@@ -3468,7 +3376,6 @@
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
4B47AC8210B5890100469C67 /* JackMachPort.h in Headers */,
4B47AC8310B5890100469C67 /* JackError.h in Headers */,
4B47AC8410B5890100469C67 /* JackTime.h in Headers */,
4B47AC8510B5890100469C67 /* JackShmMem.h in Headers */,
@@ -3489,7 +3396,6 @@
4B47AC9410B5890100469C67 /* JackMachSemaphore.h in Headers */,
4B47AC9510B5890100469C67 /* JackGlobals.h in Headers */,
4B47AC9610B5890100469C67 /* JackMachThread.h in Headers */,
4B47AC9710B5890100469C67 /* JackMachClientChannel.h in Headers */,
4B47AC9810B5890100469C67 /* JackSynchro.h in Headers */,
4B47AC9910B5890100469C67 /* JackDebugClient.h in Headers */,
4B47AC9A10B5890100469C67 /* JackConstants.h in Headers */,
@@ -3551,7 +3457,6 @@
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
4B699C02097D421600A18468 /* JackMachPort.h in Headers */,
4B699C03097D421600A18468 /* JackError.h in Headers */,
4B699C04097D421600A18468 /* JackTime.h in Headers */,
4B699C05097D421600A18468 /* JackShmMem.h in Headers */,
@@ -3572,7 +3477,6 @@
4B699C16097D421600A18468 /* JackMachSemaphore.h in Headers */,
4B699C17097D421600A18468 /* JackGlobals.h in Headers */,
4B699C18097D421600A18468 /* JackMachThread.h in Headers */,
4B699C19097D421600A18468 /* JackMachClientChannel.h in Headers */,
4B699C20097D421600A18468 /* JackSynchro.h in Headers */,
4B699C21097D421600A18468 /* JackDebugClient.h in Headers */,
4B699C22097D421600A18468 /* JackConstants.h in Headers */,
@@ -3603,7 +3507,6 @@
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
4B699C4E097D421600A18468 /* JackMachPort.h in Headers */,
4B699C4F097D421600A18468 /* JackError.h in Headers */,
4B699C50097D421600A18468 /* JackTime.h in Headers */,
4B699C51097D421600A18468 /* JackShmMem.h in Headers */,
@@ -3632,9 +3535,6 @@
4B699C71097D421600A18468 /* JackEngine.h in Headers */,
4B699C73097D421600A18468 /* JackExternalClient.h in Headers */,
4B699C74097D421600A18468 /* JackServer.h in Headers */,
4B699C77097D421600A18468 /* JackMachNotifyChannel.h in Headers */,
4B699C78097D421600A18468 /* JackMachServerChannel.h in Headers */,
4B699C79097D421600A18468 /* JackMachServerNotifyChannel.h in Headers */,
4B699C7B097D421600A18468 /* JackConstants.h in Headers */,
4BD4B4D809BACD9600750C0F /* JackTransportEngine.h in Headers */,
4BC2168E0A444BED00BDA09F /* JackServerGlobals.h in Headers */,
@@ -3788,7 +3688,6 @@
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
4BA3393510B2E36800190E3B /* JackMachPort.h in Headers */,
4BA3393610B2E36800190E3B /* JackError.h in Headers */,
4BA3393710B2E36800190E3B /* JackTime.h in Headers */,
4BA3393810B2E36800190E3B /* JackShmMem.h in Headers */,
@@ -3817,9 +3716,6 @@
4BA3394F10B2E36800190E3B /* JackEngine.h in Headers */,
4BA3395010B2E36800190E3B /* JackExternalClient.h in Headers */,
4BA3395110B2E36800190E3B /* JackServer.h in Headers */,
4BA3395210B2E36800190E3B /* JackMachNotifyChannel.h in Headers */,
4BA3395310B2E36800190E3B /* JackMachServerChannel.h in Headers */,
4BA3395410B2E36800190E3B /* JackMachServerNotifyChannel.h in Headers */,
4BA3395510B2E36800190E3B /* JackConstants.h in Headers */,
4BA3395610B2E36800190E3B /* JackTransportEngine.h in Headers */,
4BA3395710B2E36800190E3B /* JackServerGlobals.h in Headers */,
@@ -6329,8 +6225,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4B35C4590D4731D1000DE7AE /* JackRPCEngineUser.c in Sources */,
4B35C45A0D4731D1000DE7AE /* JackMachPort.cpp in Sources */,
4B35C45B0D4731D1000DE7AE /* JackShmMem.cpp in Sources */,
4B35C45C0D4731D1000DE7AE /* shm.c in Sources */,
4B35C45E0D4731D1000DE7AE /* JackActivationCount.cpp in Sources */,
@@ -6370,7 +6264,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4B35C4C40D4731D1000DE7AE /* JackMachPort.cpp in Sources */,
4B35C4C50D4731D1000DE7AE /* JackShmMem.cpp in Sources */,
4B35C4C60D4731D1000DE7AE /* shm.c in Sources */,
4B35C4C80D4731D1000DE7AE /* JackActivationCount.cpp in Sources */,
@@ -6392,7 +6285,6 @@
4B35C4DD0D4731D1000DE7AE /* JackEngine.cpp in Sources */,
4B35C4DE0D4731D1000DE7AE /* JackExternalClient.cpp in Sources */,
4B35C4DF0D4731D1000DE7AE /* JackInternalClient.cpp in Sources */,
4B35C4E00D4731D1000DE7AE /* JackRPCClientUser.c in Sources */,
4B35C4E20D4731D1000DE7AE /* JackServer.cpp in Sources */,
4B35C4EB0D4731D1000DE7AE /* JackTransportEngine.cpp in Sources */,
4B35C4EC0D4731D1000DE7AE /* JackServerAPI.cpp in Sources */,
@@ -6690,9 +6582,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4B47ACAE10B5890100469C67 /* JackMacLibClientRPC.cpp in Sources */,
4B47ACAF10B5890100469C67 /* JackRPCEngineUser.c in Sources */,
4B47ACB010B5890100469C67 /* JackMachPort.cpp in Sources */,
4B47ACB110B5890100469C67 /* JackShmMem.cpp in Sources */,
4B47ACB210B5890100469C67 /* shm.c in Sources */,
4B47ACB310B5890100469C67 /* JackActivationCount.cpp in Sources */,
@@ -6706,7 +6595,6 @@
4B47ACBB10B5890100469C67 /* JackFrameTimer.cpp in Sources */,
4B47ACBC10B5890100469C67 /* JackMachSemaphore.cpp in Sources */,
4B47ACBD10B5890100469C67 /* JackMachThread.cpp in Sources */,
4B47ACBE10B5890100469C67 /* JackMachClientChannel.cpp in Sources */,
4B47ACBF10B5890100469C67 /* JackGlobals.cpp in Sources */,
4B47ACC010B5890100469C67 /* ringbuffer.c in Sources */,
4B47ACC110B5890100469C67 /* JackDebugClient.cpp in Sources */,
@@ -6767,9 +6655,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4B699C25097D421600A18468 /* JackMacLibClientRPC.cpp in Sources */,
4B699C26097D421600A18468 /* JackRPCEngineUser.c in Sources */,
4B699C27097D421600A18468 /* JackMachPort.cpp in Sources */,
4B699C28097D421600A18468 /* JackShmMem.cpp in Sources */,
4B699C29097D421600A18468 /* shm.c in Sources */,
4B699C2B097D421600A18468 /* JackActivationCount.cpp in Sources */,
@@ -6783,7 +6668,6 @@
4B699C33097D421600A18468 /* JackFrameTimer.cpp in Sources */,
4B699C35097D421600A18468 /* JackMachSemaphore.cpp in Sources */,
4B699C36097D421600A18468 /* JackMachThread.cpp in Sources */,
4B699C37097D421600A18468 /* JackMachClientChannel.cpp in Sources */,
4B699C3D097D421600A18468 /* JackGlobals.cpp in Sources */,
4B699C3F097D421600A18468 /* ringbuffer.c in Sources */,
4B699C40097D421600A18468 /* JackDebugClient.cpp in Sources */,
@@ -6808,7 +6692,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4B699C7E097D421600A18468 /* JackMachPort.cpp in Sources */,
4B699C7F097D421600A18468 /* JackShmMem.cpp in Sources */,
4B699C80097D421600A18468 /* shm.c in Sources */,
4B699C82097D421600A18468 /* JackActivationCount.cpp in Sources */,
@@ -6830,12 +6713,7 @@
4B699C97097D421600A18468 /* JackEngine.cpp in Sources */,
4B699C99097D421600A18468 /* JackExternalClient.cpp in Sources */,
4B699C9A097D421600A18468 /* JackInternalClient.cpp in Sources */,
4B699C9B097D421600A18468 /* JackRPCClientUser.c in Sources */,
4B699C9D097D421600A18468 /* JackServer.cpp in Sources */,
4B699CA1097D421600A18468 /* JackMacEngineRPC.cpp in Sources */,
4B699CA2097D421600A18468 /* JackMachNotifyChannel.cpp in Sources */,
4B699CA3097D421600A18468 /* JackMachServerChannel.cpp in Sources */,
4B699CA4097D421600A18468 /* JackMachServerNotifyChannel.cpp in Sources */,
4BD4B4D909BACD9600750C0F /* JackTransportEngine.cpp in Sources */,
4BC216850A444BAD00BDA09F /* JackServerAPI.cpp in Sources */,
4BC216890A444BDE00BDA09F /* JackServerGlobals.cpp in Sources */,
@@ -6990,7 +6868,6 @@
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4BA3397210B2E36800190E3B /* JackMachPort.cpp in Sources */,
4BA3397310B2E36800190E3B /* JackShmMem.cpp in Sources */,
4BA3397410B2E36800190E3B /* shm.c in Sources */,
4BA3397510B2E36800190E3B /* JackActivationCount.cpp in Sources */,
@@ -7012,12 +6889,7 @@
4BA3398510B2E36800190E3B /* JackEngine.cpp in Sources */,
4BA3398610B2E36800190E3B /* JackExternalClient.cpp in Sources */,
4BA3398710B2E36800190E3B /* JackInternalClient.cpp in Sources */,
4BA3398810B2E36800190E3B /* JackRPCClientUser.c in Sources */,
4BA3398910B2E36800190E3B /* JackServer.cpp in Sources */,
4BA3398A10B2E36800190E3B /* JackMacEngineRPC.cpp in Sources */,
4BA3398B10B2E36800190E3B /* JackMachNotifyChannel.cpp in Sources */,
4BA3398C10B2E36800190E3B /* JackMachServerChannel.cpp in Sources */,
4BA3398D10B2E36800190E3B /* JackMachServerNotifyChannel.cpp in Sources */,
4BA3398E10B2E36800190E3B /* JackTransportEngine.cpp in Sources */,
4BA3398F10B2E36800190E3B /* JackServerAPI.cpp in Sources */,
4BA3399010B2E36800190E3B /* JackServerGlobals.cpp in Sources */,


+ 0
- 47
macosx/RPC/JackRPCClient.defs View File

@@ -1,47 +0,0 @@
/*
Copyright (C) 2004 Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

subsystem JackRPCClient 1000;

#include <mach/std_types.defs>
#include <mach/mach_types.defs>
import "Jackdefs.h";
waittime 5000;

type client_name_t = c_string[64];
type message_t = c_string[256];

routine rpc_jack_client_sync_notify(
client_port : mach_port_t;
refnum : int;
client_name : client_name_t;
notify : int;
message : message_t;
value1 : int;
value2 : int;
out result : int);

simpleroutine rpc_jack_client_async_notify(
client_port : mach_port_t;
refnum : int;
client_name : client_name_t;
notify : int;
message : message_t;
value1 : int;
value2 : int);

+ 0
- 194
macosx/RPC/JackRPCClient.h View File

@@ -1,194 +0,0 @@
#ifndef _JackRPCClient_user_
#define _JackRPCClient_user_

/* Module JackRPCClient */

#include <string.h>
#include <mach/ndr.h>
#include <mach/boolean.h>
#include <mach/kern_return.h>
#include <mach/notify.h>
#include <mach/mach_types.h>
#include <mach/message.h>
#include <mach/mig_errors.h>
#include <mach/port.h>

#ifdef AUTOTEST
#ifndef FUNCTION_PTR_T
#define FUNCTION_PTR_T
typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
typedef struct {
char *name;
function_ptr_t function;
} function_table_entry;
typedef function_table_entry *function_table_t;
#endif /* FUNCTION_PTR_T */
#endif /* AUTOTEST */

#ifndef JackRPCClient_MSG_COUNT
#define JackRPCClient_MSG_COUNT 2
#endif /* JackRPCClient_MSG_COUNT */

#include <mach/std_types.h>
#include <mach/mig.h>
#include <mach/mig.h>
#include <mach/mach_types.h>
#include "Jackdefs.h"

#ifdef __BeforeMigUserHeader
__BeforeMigUserHeader
#endif /* __BeforeMigUserHeader */

#include <sys/cdefs.h>
__BEGIN_DECLS


/* Routine rpc_jack_client_sync_notify */
#ifdef mig_external
mig_external
#else
extern
#endif /* mig_external */
kern_return_t rpc_jack_client_sync_notify
(
mach_port_t client_port,
int refnum,
client_name_t client_name,
int notify,
message_t message,
int value1,
int value2,
int *result
);

/* SimpleRoutine rpc_jack_client_async_notify */
#ifdef mig_external
mig_external
#else
extern
#endif /* mig_external */
kern_return_t rpc_jack_client_async_notify
(
mach_port_t client_port,
int refnum,
client_name_t client_name,
int notify,
message_t message,
int value1,
int value2
);

__END_DECLS

/********************** Caution **************************/
/* The following data types should be used to calculate */
/* maximum message sizes only. The actual message may be */
/* smaller, and the position of the arguments within the */
/* message layout may vary from what is presented here. */
/* For example, if any of the arguments are variable- */
/* sized, and less than the maximum is sent, the data */
/* will be packed tight in the actual message to reduce */
/* the presence of holes. */
/********************** Caution **************************/

/* typedefs for all requests */

#ifndef __Request__JackRPCClient_subsystem__defined
#define __Request__JackRPCClient_subsystem__defined

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
int refnum;
client_name_t client_name;
int notify;
message_t message;
int value1;
int value2;
} __Request__rpc_jack_client_sync_notify_t;
#ifdef __MigPackStructs
#pragma pack()
#endif

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
int refnum;
client_name_t client_name;
int notify;
message_t message;
int value1;
int value2;
} __Request__rpc_jack_client_async_notify_t;
#ifdef __MigPackStructs
#pragma pack()
#endif
#endif /* !__Request__JackRPCClient_subsystem__defined */

/* union of all requests */

#ifndef __RequestUnion__JackRPCClient_subsystem__defined
#define __RequestUnion__JackRPCClient_subsystem__defined
union __RequestUnion__JackRPCClient_subsystem {
__Request__rpc_jack_client_sync_notify_t Request_rpc_jack_client_sync_notify;
__Request__rpc_jack_client_async_notify_t Request_rpc_jack_client_async_notify;
};
#endif /* !__RequestUnion__JackRPCClient_subsystem__defined */
/* typedefs for all replies */

#ifndef __Reply__JackRPCClient_subsystem__defined
#define __Reply__JackRPCClient_subsystem__defined

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
kern_return_t RetCode;
int result;
} __Reply__rpc_jack_client_sync_notify_t;
#ifdef __MigPackStructs
#pragma pack()
#endif

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
kern_return_t RetCode;
} __Reply__rpc_jack_client_async_notify_t;
#ifdef __MigPackStructs
#pragma pack()
#endif
#endif /* !__Reply__JackRPCClient_subsystem__defined */

/* union of all replies */

#ifndef __ReplyUnion__JackRPCClient_subsystem__defined
#define __ReplyUnion__JackRPCClient_subsystem__defined
union __ReplyUnion__JackRPCClient_subsystem {
__Reply__rpc_jack_client_sync_notify_t Reply_rpc_jack_client_sync_notify;
__Reply__rpc_jack_client_async_notify_t Reply_rpc_jack_client_async_notify;
};
#endif /* !__RequestUnion__JackRPCClient_subsystem__defined */

#ifndef subsystem_to_name_map_JackRPCClient
#define subsystem_to_name_map_JackRPCClient \
{ "rpc_jack_client_sync_notify", 1000 },\
{ "rpc_jack_client_async_notify", 1001 }
#endif

#ifdef __AfterMigUserHeader
__AfterMigUserHeader
#endif /* __AfterMigUserHeader */

#endif /* _JackRPCClient_user_ */

+ 0
- 1373
macosx/RPC/JackRPCClientServer.c
File diff suppressed because it is too large
View File


+ 0
- 466
macosx/RPC/JackRPCClientUser.c View File

@@ -1,466 +0,0 @@
/*
* IDENTIFICATION:
* stub generated Fri Oct 23 10:35:08 2009
* with a MiG generated Mon May 18 09:59:33 PDT 2009 by root@sulitlana.apple.com
* OPTIONS:
*/
#define __MIG_check__Reply__JackRPCClient_subsystem__ 1
#define __NDR_convert__Reply__JackRPCClient_subsystem__ 1
#define __NDR_convert__mig_reply_error_subsystem__ 1

#include "JackRPCClient.h"


#ifndef mig_internal
#define mig_internal static __inline__
#endif /* mig_internal */

#ifndef mig_external
#define mig_external
#endif /* mig_external */

#if !defined(__MigTypeCheck) && defined(TypeCheck)
#define __MigTypeCheck TypeCheck /* Legacy setting */
#endif /* !defined(__MigTypeCheck) */

#if !defined(__MigKernelSpecificCode) && defined(_MIG_KERNEL_SPECIFIC_CODE_)
#define __MigKernelSpecificCode _MIG_KERNEL_SPECIFIC_CODE_ /* Legacy setting */
#endif /* !defined(__MigKernelSpecificCode) */

#ifndef LimitCheck
#define LimitCheck 0
#endif /* LimitCheck */

#ifndef min
#define min(a,b) ( ((a) < (b))? (a): (b) )
#endif /* min */

#if !defined(_WALIGN_)
#define _WALIGN_(x) (((x) + 3) & ~3)
#endif /* !defined(_WALIGN_) */

#if !defined(_WALIGNSZ_)
#define _WALIGNSZ_(x) _WALIGN_(sizeof(x))
#endif /* !defined(_WALIGNSZ_) */

#ifndef UseStaticTemplates
#define UseStaticTemplates 0
#endif /* UseStaticTemplates */

#ifndef __MachMsgErrorWithTimeout
#define __MachMsgErrorWithTimeout(_R_) { \
switch (_R_) { \
case MACH_SEND_INVALID_DATA: \
case MACH_SEND_INVALID_DEST: \
case MACH_SEND_INVALID_HEADER: \
mig_put_reply_port(InP->Head.msgh_reply_port); \
break; \
case MACH_SEND_TIMED_OUT: \
case MACH_RCV_TIMED_OUT: \
default: \
mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
} \
}
#endif /* __MachMsgErrorWithTimeout */

#ifndef __MachMsgErrorWithoutTimeout
#define __MachMsgErrorWithoutTimeout(_R_) { \
switch (_R_) { \
case MACH_SEND_INVALID_DATA: \
case MACH_SEND_INVALID_DEST: \
case MACH_SEND_INVALID_HEADER: \
mig_put_reply_port(InP->Head.msgh_reply_port); \
break; \
default: \
mig_dealloc_reply_port(InP->Head.msgh_reply_port); \
} \
}
#endif /* __MachMsgErrorWithoutTimeout */

#ifndef __DeclareSendRpc
#define __DeclareSendRpc(_NUM_, _NAME_)
#endif /* __DeclareSendRpc */

#ifndef __BeforeSendRpc
#define __BeforeSendRpc(_NUM_, _NAME_)
#endif /* __BeforeSendRpc */

#ifndef __AfterSendRpc
#define __AfterSendRpc(_NUM_, _NAME_)
#endif /* __AfterSendRpc */

#ifndef __DeclareSendSimple
#define __DeclareSendSimple(_NUM_, _NAME_)
#endif /* __DeclareSendSimple */

#ifndef __BeforeSendSimple
#define __BeforeSendSimple(_NUM_, _NAME_)
#endif /* __BeforeSendSimple */

#ifndef __AfterSendSimple
#define __AfterSendSimple(_NUM_, _NAME_)
#endif /* __AfterSendSimple */

#define msgh_request_port msgh_remote_port
#define msgh_reply_port msgh_local_port



#if ( __MigTypeCheck || __NDR_convert__ )
#if __MIG_check__Reply__JackRPCClient_subsystem__
#if !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
#define __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
#if defined(__NDR_convert__int_rep__JackRPCClient__kern_return_t__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
__NDR_convert__int_rep__JackRPCClient__kern_return_t((kern_return_t *)(a), f)
#elif defined(__NDR_convert__int_rep__kern_return_t__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(a, f) \
__NDR_convert__int_rep__kern_return_t((kern_return_t *)(a), f)
#endif /* defined(__NDR_convert__*__defined) */
#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */


#ifndef __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#if defined(__NDR_convert__int_rep__JackRPCClient__int__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__int_rep__JackRPCClient__int((int *)(a), f)
#elif defined(__NDR_convert__int_rep__int__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__int_rep__int((int *)(a), f)
#elif defined(__NDR_convert__int_rep__JackRPCClient__int32_t__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__int_rep__JackRPCClient__int32_t((int32_t *)(a), f)
#elif defined(__NDR_convert__int_rep__int32_t__defined)
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__int_rep__int32_t((int32_t *)(a), f)
#endif /* defined(__NDR_convert__*__defined) */
#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */



#ifndef __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#if defined(__NDR_convert__char_rep__JackRPCClient__int__defined)
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__char_rep__JackRPCClient__int((int *)(a), f)
#elif defined(__NDR_convert__char_rep__int__defined)
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__char_rep__int((int *)(a), f)
#elif defined(__NDR_convert__char_rep__JackRPCClient__int32_t__defined)
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__char_rep__JackRPCClient__int32_t((int32_t *)(a), f)
#elif defined(__NDR_convert__char_rep__int32_t__defined)
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__char_rep__int32_t((int32_t *)(a), f)
#endif /* defined(__NDR_convert__*__defined) */
#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */



#ifndef __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#if defined(__NDR_convert__float_rep__JackRPCClient__int__defined)
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__float_rep__JackRPCClient__int((int *)(a), f)
#elif defined(__NDR_convert__float_rep__int__defined)
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__float_rep__int((int *)(a), f)
#elif defined(__NDR_convert__float_rep__JackRPCClient__int32_t__defined)
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__float_rep__JackRPCClient__int32_t((int32_t *)(a), f)
#elif defined(__NDR_convert__float_rep__int32_t__defined)
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined
#define __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(a, f) \
__NDR_convert__float_rep__int32_t((int32_t *)(a), f)
#endif /* defined(__NDR_convert__*__defined) */
#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */



mig_internal kern_return_t __MIG_check__Reply__rpc_jack_client_sync_notify_t(__Reply__rpc_jack_client_sync_notify_t *Out0P)
{

typedef __Reply__rpc_jack_client_sync_notify_t __Reply;
#if __MigTypeCheck
unsigned int msgh_size;
#endif /* __MigTypeCheck */
if (Out0P->Head.msgh_id != 1100) {
if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
{ return MIG_SERVER_DIED; }
else
{ return MIG_REPLY_MISMATCH; }
}

#if __MigTypeCheck
msgh_size = Out0P->Head.msgh_size;

if ((Out0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||
((msgh_size != (mach_msg_size_t)sizeof(__Reply)) &&
(msgh_size != (mach_msg_size_t)sizeof(mig_reply_error_t) ||
Out0P->RetCode == KERN_SUCCESS)))
{ return MIG_TYPE_ERROR ; }
#endif /* __MigTypeCheck */

if (Out0P->RetCode != KERN_SUCCESS) {
#ifdef __NDR_convert__mig_reply_error_t__defined
__NDR_convert__mig_reply_error_t((mig_reply_error_t *)Out0P);
#endif /* __NDR_convert__mig_reply_error_t__defined */
return ((mig_reply_error_t *)Out0P)->RetCode;
}

#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined) || \
defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
if (Out0P->NDR.int_rep != NDR_record.int_rep) {
#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined)
__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__RetCode__defined */
#if defined(__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
__NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.int_rep);
#endif /* __NDR_convert__int_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
}
#endif /* defined(__NDR_convert__int_rep...) */

#if 0 || \
defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
if (Out0P->NDR.char_rep != NDR_record.char_rep) {
#if defined(__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
__NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.char_rep);
#endif /* __NDR_convert__char_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
}
#endif /* defined(__NDR_convert__char_rep...) */

#if 0 || \
defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
if (Out0P->NDR.float_rep != NDR_record.float_rep) {
#if defined(__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined)
__NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result(&Out0P->result, Out0P->NDR.float_rep);
#endif /* __NDR_convert__float_rep__Reply__rpc_jack_client_sync_notify_t__result__defined */
}
#endif /* defined(__NDR_convert__float_rep...) */

return MACH_MSG_SUCCESS;
}
#endif /* !defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */
#endif /* __MIG_check__Reply__JackRPCClient_subsystem__ */
#endif /* ( __MigTypeCheck || __NDR_convert__ ) */


/* Routine rpc_jack_client_sync_notify */
mig_external kern_return_t rpc_jack_client_sync_notify
(
mach_port_t client_port,
int refnum,
client_name_t client_name,
int notify,
message_t message,
int value1,
int value2,
int *result
)
{

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
int refnum;
client_name_t client_name;
int notify;
message_t message;
int value1;
int value2;
} Request;
#ifdef __MigPackStructs
#pragma pack()
#endif

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
kern_return_t RetCode;
int result;
mach_msg_trailer_t trailer;
} Reply;
#ifdef __MigPackStructs
#pragma pack()
#endif

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
kern_return_t RetCode;
int result;
} __Reply;
#ifdef __MigPackStructs
#pragma pack()
#endif
/*
* typedef struct {
* mach_msg_header_t Head;
* NDR_record_t NDR;
* kern_return_t RetCode;
* } mig_reply_error_t;
*/

union {
Request In;
Reply Out;
} Mess;

Request *InP = &Mess.In;
Reply *Out0P = &Mess.Out;

mach_msg_return_t msg_result;

#ifdef __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined
kern_return_t check_result;
#endif /* __MIG_check__Reply__rpc_jack_client_sync_notify_t__defined */

__DeclareSendRpc(1000, "rpc_jack_client_sync_notify")

InP->NDR = NDR_record;

InP->refnum = refnum;

(void) mig_strncpy(InP->client_name, client_name, 64);

InP->notify = notify;

(void) mig_strncpy(InP->message, message, 256);

InP->value1 = value1;

InP->value2 = value2;

InP->Head.msgh_bits =
MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE);
/* msgh_size passed as argument */
InP->Head.msgh_request_port = client_port;
InP->Head.msgh_reply_port = mig_get_reply_port();
InP->Head.msgh_id = 1000;

__BeforeSendRpc(1000, "rpc_jack_client_sync_notify")
msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_SEND_TIMEOUT|MACH_RCV_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, 5000, MACH_PORT_NULL);
__AfterSendRpc(1000, "rpc_jack_client_sync_notify")

if (msg_result == MACH_SEND_TIMED_OUT) {
}

if (msg_result != MACH_MSG_SUCCESS) {
__MachMsgErrorWithTimeout(msg_result);
{ return msg_result; }
}


#if defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined)
check_result = __MIG_check__Reply__rpc_jack_client_sync_notify_t((__Reply__rpc_jack_client_sync_notify_t *)Out0P);
if (check_result != MACH_MSG_SUCCESS)
{ return check_result; }
#endif /* defined(__MIG_check__Reply__rpc_jack_client_sync_notify_t__defined) */

*result = Out0P->result;

return KERN_SUCCESS;
}

/* SimpleRoutine rpc_jack_client_async_notify */
mig_external kern_return_t rpc_jack_client_async_notify
(
mach_port_t client_port,
int refnum,
client_name_t client_name,
int notify,
message_t message,
int value1,
int value2
)
{

#ifdef __MigPackStructs
#pragma pack(4)
#endif
typedef struct {
mach_msg_header_t Head;
NDR_record_t NDR;
int refnum;
client_name_t client_name;
int notify;
message_t message;
int value1;
int value2;
} Request;
#ifdef __MigPackStructs
#pragma pack()
#endif
/*
* typedef struct {
* mach_msg_header_t Head;
* NDR_record_t NDR;
* kern_return_t RetCode;
* } mig_reply_error_t;
*/

union {
Request In;
} Mess;

Request *InP = &Mess.In;

mach_msg_return_t msg_result;

#ifdef __MIG_check__Reply__rpc_jack_client_async_notify_t__defined
kern_return_t check_result;
#endif /* __MIG_check__Reply__rpc_jack_client_async_notify_t__defined */

__DeclareSendSimple(1001, "rpc_jack_client_async_notify")

InP->NDR = NDR_record;

InP->refnum = refnum;

(void) mig_strncpy(InP->client_name, client_name, 64);

InP->notify = notify;

(void) mig_strncpy(InP->message, message, 256);

InP->value1 = value1;

InP->value2 = value2;

InP->Head.msgh_bits =
MACH_MSGH_BITS(19, 0);
/* msgh_size passed as argument */
InP->Head.msgh_request_port = client_port;
InP->Head.msgh_reply_port = MACH_PORT_NULL;
InP->Head.msgh_id = 1001;

__BeforeSendSimple(1001, "rpc_jack_client_async_notify")
msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_SEND_TIMEOUT|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), 0, MACH_PORT_NULL, 5000, MACH_PORT_NULL);
__AfterSendSimple(1001, "rpc_jack_client_async_notify")

if (msg_result == MACH_SEND_TIMED_OUT) {
}

return msg_result;
}

+ 0
- 181
macosx/RPC/JackRPCEngine.defs View File

@@ -1,181 +0,0 @@
/*
Copyright (C) 2004 Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

subsystem JackRPCEngine 1000;

#include <mach/std_types.defs>
#include <mach/mach_types.defs>
import "Jackdefs.h";

ServerPrefix server_;

type client_name_t = c_string[64];
type client_port_name_t = c_string[128];
type client_port_type_t = c_string[128];
type so_name_t = c_string[256];
type objet_data_t = c_string[256];

routine rpc_jack_client_open(
server_port : mach_port_t;
client_name : client_name_t;
pid : int;
out private_port : mach_port_make_send_t;
out shared_engine : int;
out shared_client : int;
out shared_graph : int;
out result : int);

routine rpc_jack_client_check(
server_port : mach_port_t;
client_name : client_name_t;
out client_name_res : client_name_t;
protocol : int;
options : int;
out status : int;
out result : int);

routine rpc_jack_client_close(
server_port : mach_port_t;
refnum : int;
out result : int);
routine rpc_jack_client_activate(
server_port : mach_port_t;
refnum : int;
state : int;
out result : int);

routine rpc_jack_client_deactivate(
server_port : mach_port_t;
refnum : int;
out result : int);

routine rpc_jack_port_register(
server_port : mach_port_t;
refnum : int;
name : client_port_name_t;
port_type : client_port_type_t;
flags : unsigned;
buffer_size : unsigned;
out port_index : unsigned;
out result : int);
routine rpc_jack_port_unregister(
server_port : mach_port_t;
refnum : int;
port : int;
out result : int);
routine rpc_jack_port_connect(
server_port : mach_port_t;
refnum : int;
src : int;
dst : int;
out result : int);
routine rpc_jack_port_disconnect(
server_port : mach_port_t;
refnum : int;
src : int;
dst : int;
out result : int);
routine rpc_jack_port_connect_name(
server_port : mach_port_t;
refnum : int;
src : client_port_name_t;
dst : client_port_name_t;
out result : int);
routine rpc_jack_port_disconnect_name(
server_port : mach_port_t;
refnum : int;
src : client_port_name_t;
dst : client_port_name_t;
out result : int);
routine rpc_jack_port_rename(
server_port : mach_port_t;
refnum : int;
src : int;
name : client_port_name_t;
out result : int);

routine rpc_jack_set_buffer_size(
server_port : mach_port_t;
buffer_size : int;
out result : int);
routine rpc_jack_set_freewheel(
server_port : mach_port_t;
onoff : int;
out result : int);

routine rpc_jack_release_timebase(
server_port : mach_port_t;
refnum : int;
out result : int);
routine rpc_jack_set_timebase_callback(
server_port : mach_port_t;
refnum : int;
conditional : int;
out result : int);
routine rpc_jack_get_internal_clientname(
server_port : mach_port_t;
refnum : int;
int_ref : int;
out client_name_res : client_name_t;
out result : int);
routine rpc_jack_internal_clienthandle(
server_port : mach_port_t;
refnum : int;
client_name : client_name_t;
out int_ref : int;
out status : int;
out result : int);
routine rpc_jack_internal_clientload(
server_port : mach_port_t;
refnum : int;
client_name : client_name_t;
so_name : so_name_t;
objet_data : objet_data_t;
options : int;
out status : int;
out int_ref : int;
out result : int);
routine rpc_jack_internal_clientunload(
server_port : mach_port_t;
refnum : int;
int_ref : int;
out status : int;
out result : int);

simpleroutine rpc_jack_client_rt_notify(
client_port : mach_port_t;
refnum : int;
notify : int;
value : int;
waittime timeout : int);


+ 0
- 1040
macosx/RPC/JackRPCEngine.h
File diff suppressed because it is too large
View File


+ 0
- 6817
macosx/RPC/JackRPCEngineServer.c
File diff suppressed because it is too large
View File


+ 0
- 6302
macosx/RPC/JackRPCEngineUser.c
File diff suppressed because it is too large
View File


+ 0
- 25
macosx/RPC/Jackdefs.h View File

@@ -1,25 +0,0 @@
/*
Copyright (C) 2004-2006 Grame

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

typedef char client_name_t[64];
typedef char client_port_name_t[128];
typedef char client_port_type_t[128];
typedef char so_name_t[256];
typedef char objet_data_t[256];
typedef char message_t[256];

Loading…
Cancel
Save