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