@@ -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', | |||
] | |||
@@ -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; | |||
} | |||
} |
@@ -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; | |||
} | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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 | |||
@@ -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; } | |||
@@ -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 */, | |||
@@ -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); |
@@ -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_ */ |
@@ -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; | |||
} |
@@ -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); | |||
@@ -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]; |