| @@ -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]; | |||