00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackServer.h"
00021 #include "JackNotification.h"
00022 #include "JackLockedEngine.h"
00023 #include "JackRPCEngine.h"
00024 #include "JackMachServerChannel.h"
00025 #include "JackException.h"
00026 #include <assert.h>
00027
00028 using namespace Jack;
00029
00030
00031
00032
00033
00034 #define rpc_type kern_return_t // for astyle
00035
00036 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)
00037 {
00038 jack_log("rpc_jack_client_check");
00039 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00040 assert(channel);
00041 channel->ClientCheck((char*)name, (char*)name_res, protocol, options, status, result);
00042 return KERN_SUCCESS;
00043 }
00044
00045 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)
00046 {
00047 jack_log("rpc_jack_client_open name = %s", name);
00048 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00049 assert(channel);
00050 channel->ClientOpen((char*)name, pid, private_port, shared_engine, shared_client, shared_graph, result);
00051 return KERN_SUCCESS;
00052 }
00053
00054 rpc_type server_rpc_jack_client_close(mach_port_t private_port, int refnum, int* result)
00055 {
00056 jack_log("rpc_jack_client_close");
00057 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00058 assert(channel);
00059 channel->ClientClose(private_port, refnum);
00060 *result = 0;
00061 return KERN_SUCCESS;
00062 }
00063
00064 rpc_type server_rpc_jack_client_activate(mach_port_t private_port, int refnum, int is_real_time, int* result)
00065 {
00066 jack_log("rpc_jack_client_activate");
00067 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00068 assert(channel);
00069 *result = channel->GetEngine()->ClientActivate(refnum, is_real_time);
00070 return KERN_SUCCESS;
00071 }
00072
00073 rpc_type server_rpc_jack_client_deactivate(mach_port_t private_port, int refnum, int* result)
00074 {
00075 jack_log("rpc_jack_client_deactivate");
00076 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00077 assert(channel);
00078 *result = channel->GetEngine()->ClientDeactivate(refnum);
00079 return KERN_SUCCESS;
00080 }
00081
00082
00083
00084
00085
00086 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)
00087 {
00088 jack_log("rpc_jack_port_register ref = %d name = %s", refnum, name);
00089 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00090 assert(channel);
00091 *result = channel->GetEngine()->PortRegister(refnum, name, type, flags, buffer_size, port_index);
00092 return KERN_SUCCESS;
00093 }
00094
00095 rpc_type server_rpc_jack_port_unregister(mach_port_t private_port, int refnum, int port, int* result)
00096 {
00097 jack_log("rpc_jack_port_unregister ref = %d port = %d ", refnum, port);
00098 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00099 assert(channel);
00100 *result = channel->GetEngine()->PortUnRegister(refnum, port);
00101 return KERN_SUCCESS;
00102 }
00103
00104 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)
00105 {
00106 jack_log("rpc_jack_port_connect_name");
00107 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00108 assert(channel);
00109 *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00110 return KERN_SUCCESS;
00111 }
00112
00113 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)
00114 {
00115 jack_log("rpc_jack_port_disconnect_name");
00116 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00117 assert(channel);
00118 *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00119 return KERN_SUCCESS;
00120 }
00121
00122 rpc_type server_rpc_jack_port_connect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00123 {
00124 jack_log("rpc_jack_port_connect");
00125 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00126 assert(channel);
00127 *result = channel->GetEngine()->PortConnect(refnum, src, dst);
00128 return KERN_SUCCESS;
00129 }
00130
00131 rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, int src, int dst, int* result)
00132 {
00133 jack_log("rpc_jack_port_disconnect");
00134 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00135 assert(channel);
00136 *result = channel->GetEngine()->PortDisconnect(refnum, src, dst);
00137 return KERN_SUCCESS;
00138 }
00139
00140 rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
00141 {
00142 jack_log("server_rpc_jack_port_rename");
00143 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00144 assert(channel);
00145 *result = channel->GetEngine()->PortRename(refnum, port, name);
00146 return KERN_SUCCESS;
00147 }
00148
00149
00150
00151
00152
00153 rpc_type server_rpc_jack_set_buffer_size(mach_port_t private_port, int buffer_size, int* result)
00154 {
00155 jack_log("server_rpc_jack_set_buffer_size");
00156 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00157 assert(channel);
00158 *result = channel->GetServer()->SetBufferSize(buffer_size);
00159 return KERN_SUCCESS;
00160 }
00161
00162 rpc_type server_rpc_jack_set_freewheel(mach_port_t private_port, int onoff, int* result)
00163 {
00164 jack_log("server_rpc_jack_set_freewheel");
00165 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00166 assert(channel);
00167 *result = channel->GetServer()->SetFreewheel(onoff);
00168 return KERN_SUCCESS;
00169 }
00170
00171
00172
00173
00174
00175 rpc_type server_rpc_jack_release_timebase(mach_port_t private_port, int refnum, int* result)
00176 {
00177 jack_log("server_rpc_jack_release_timebase");
00178 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00179 assert(channel);
00180 *result = channel->GetServer()->ReleaseTimebase(refnum);
00181 return KERN_SUCCESS;
00182 }
00183
00184 rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int refnum, int conditional, int* result)
00185 {
00186 jack_log("server_rpc_jack_set_timebase_callback");
00187 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00188 assert(channel);
00189 *result = channel->GetServer()->SetTimebaseCallback(refnum, conditional);
00190 return KERN_SUCCESS;
00191 }
00192
00193
00194
00195
00196
00197 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)
00198 {
00199 jack_log("server_rpc_jack_get_internal_clientname");
00200 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00201 assert(channel);
00202 *result = channel->GetServer()->GetEngine()->GetInternalClientName(int_ref, (char*)name_res);
00203 return KERN_SUCCESS;
00204 }
00205
00206 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)
00207 {
00208 jack_log("server_rpc_jack_internal_clienthandle");
00209 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00210 assert(channel);
00211 *result = channel->GetServer()->GetEngine()->InternalClientHandle(client_name, status, int_ref);
00212 return KERN_SUCCESS;
00213 }
00214
00215 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)
00216 {
00217 jack_log("server_rpc_jack_internal_clientload");
00218 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00219 assert(channel);
00220 *result = channel->GetServer()->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);
00221 return KERN_SUCCESS;
00222 }
00223
00224 rpc_type server_rpc_jack_internal_clientunload(mach_port_t private_port, int refnum, int int_ref, int* status, int* result)
00225 {
00226 jack_log("server_rpc_jack_internal_clientunload");
00227 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
00228 assert(channel);
00229 *result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status);
00230 return KERN_SUCCESS;
00231 }
00232
00233
00234
00235
00236
00237 rpc_type server_rpc_jack_client_rt_notify(mach_port_t server_port, int refnum, int notify, int value)
00238 {
00239 jack_log("rpc_jack_client_rt_notify ref = %d notify = %d value = %d", refnum, notify, value);
00240 JackMachServerChannel* channel = JackMachServerChannel::fPortTable[server_port];
00241 assert(channel);
00242 assert(channel->GetServer());
00243
00244 if (notify == kQUIT) {
00245 throw JackQuitException();
00246 } else {
00247 channel->GetServer()->Notify(refnum, notify, value);
00248 return KERN_SUCCESS;
00249 }
00250 }