From 17f62de23fd434427f230c562849d7286ebb7cf6 Mon Sep 17 00:00:00 2001 From: sletz Date: Thu, 11 Oct 2007 16:04:38 +0000 Subject: [PATCH] Internal loadable client implementation (in progress). git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@1583 0c269be4-1314-0410-8aa9-9f06e86f4224 --- ChangeLog | 4 + common/JackAPI.cpp | 76 +- common/JackAPIWrapper.cpp | 2 +- common/JackChannel.h | 11 + common/JackClient.cpp | 56 + common/JackClient.h | 7 + common/JackEngine.cpp | 53 +- common/JackEngine.h | 8 +- common/JackInternalClient.cpp | 46 + common/JackInternalClient.h | 45 + common/JackServer.cpp | 24 + common/JackServer.h | 4 +- common/JackServerAPI.cpp | 25 +- common/Jackdmp.cpp | 18 +- common/jack.h | 2 +- example-clients/inprocess.c | 123 ++ example-clients/ipload.c | 171 +++ example-clients/ipunload.c | 77 + macosx/JackMacEngineRPC.cpp | 40 + macosx/JackMachClientChannel.cpp | 36 + macosx/JackMachClientChannel.h | 7 +- macosx/Jackdmp.xcodeproj/project.pbxproj | 535 ++++++- macosx/RPC/JackRPCClientServer.c | 2 +- macosx/RPC/JackRPCClientUser.c | 2 +- macosx/RPC/JackRPCEngine.defs | 35 + macosx/RPC/JackRPCEngine.h | 194 ++- macosx/RPC/JackRPCEngineServer.c | 1671 ++++++++++++++++++++-- macosx/RPC/JackRPCEngineUser.c | 1538 +++++++++++++++++++- macosx/RPC/Jackdefs.h | 6 +- 29 files changed, 4621 insertions(+), 197 deletions(-) create mode 100644 example-clients/inprocess.c create mode 100644 example-clients/ipload.c create mode 100644 example-clients/ipunload.c diff --git a/ChangeLog b/ChangeLog index d47ba063..af904082 100644 --- a/ChangeLog +++ b/ChangeLog @@ -13,6 +13,10 @@ Tom Szilagyi Jackdmp changes log --------------------------- +2007-10-11 Stephane Letz + + * Internal loadable client implementation (in progress). + 2007-10-08 Stephane Letz * Use .jackdrc file (instead of .jackdmprc). Install script now creates a link "jackd ==> jackdmp" so that automatic launch can work correctly. diff --git a/common/JackAPI.cpp b/common/JackAPI.cpp index d930a818..666f8054 100644 --- a/common/JackAPI.cpp +++ b/common/JackAPI.cpp @@ -1422,27 +1422,85 @@ EXPORT int jack_drop_real_time_scheduling(pthread_t thread) } // intclient.h + EXPORT char* jack_get_internal_client_name(jack_client_t* ext_client, jack_intclient_t intclient) { - JackLog("jack_get_internal_client_name: not yet implemented\n"); - return ""; +#ifdef __CLIENTDEBUG__ + JackLibGlobals::CheckContext(); +#endif + JackClient* client = (JackClient*)ext_client; + if (client == NULL) { + jack_error("jack_get_internal_client_name called with a NULL client"); + return ""; + } else { + return client->GetInternalClientName(intclient); + } } EXPORT jack_intclient_t jack_internal_client_handle(jack_client_t* ext_client, const char* client_name, jack_status_t* status) { - JackLog("jack_internal_client_handle: not yet implemented\n"); - return 0; +#ifdef __CLIENTDEBUG__ + JackLibGlobals::CheckContext(); +#endif + JackClient* client = (JackClient*)ext_client; + if (client == NULL) { + jack_error("jack_internal_client_handle called with a NULL client"); + return 0; + } else { + jack_status_t my_status; + if (status == NULL) /* no status from caller? */ + status = &my_status; /* use local status word */ + *status = (jack_status_t)0; + return client->InternalClientHandle(client_name, status); + } } EXPORT jack_intclient_t jack_internal_client_load(jack_client_t* ext_client, const char* client_name, jack_options_t options, jack_status_t* status, ...) { - JackLog("jack_internal_client_load: not yet implemented\n"); - return 0; +#ifdef __CLIENTDEBUG__ + JackLibGlobals::CheckContext(); +#endif + JackClient* client = (JackClient*)ext_client; + if (client == NULL) { + jack_error("jack_internal_client_load called with a NULL client"); + return 0; + } else { + va_list ap; + jack_varargs_t va; + jack_status_t my_status; + + if (status == NULL) /* no status from caller? */ + status = &my_status; /* use local status word */ + *status = (jack_status_t)0; + + /* validate parameters */ + if ((options & ~JackLoadOptions)) { + int my_status1 = *status | (JackFailure | JackInvalidOption); + *status = (jack_status_t)my_status1; + return 0; + } + + /* parse variable arguments */ + va_start(ap, status); + jack_varargs_parse(options, ap, &va); + va_end(ap); + + return client->InternalClientLoad(client_name, options, status, &va); + } } EXPORT jack_status_t jack_internal_client_unload(jack_client_t* ext_client, jack_intclient_t intclient) { - JackLog("jack_internal_client_unload: not yet implemented\n"); - return JackFailure; +#ifdef __CLIENTDEBUG__ + JackLibGlobals::CheckContext(); +#endif + JackClient* client = (JackClient*)ext_client; + if (client == NULL) { + jack_error("jack_internal_client_unload called with a NULL client"); + return (jack_status_t)(JackNoSuchClient | JackFailure); + } else { + jack_status_t my_status; + client->InternalClientUnload(intclient, &my_status); + return my_status; + } } - diff --git a/common/JackAPIWrapper.cpp b/common/JackAPIWrapper.cpp index 83ae6cfd..9fd578e7 100644 --- a/common/JackAPIWrapper.cpp +++ b/common/JackAPIWrapper.cpp @@ -35,7 +35,7 @@ extern "C" EXPORT int jack_internal_client_new (const char *client_name, const char *load_name, const char *load_init); - EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name); + EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name, const char* dll_name, const char* object_data); EXPORT void jack_internal_client_close (const char *client_name); EXPORT void my_jack_internal_client_close (jack_client_t* client); EXPORT int jack_is_realtime (jack_client_t *client); diff --git a/common/JackChannel.h b/common/JackChannel.h index b2349a93..658322e9 100644 --- a/common/JackChannel.h +++ b/common/JackChannel.h @@ -109,8 +109,19 @@ class JackClientChannelInterface {} virtual void SetTimebaseCallback(int refnum, int conditional, int* result) + {} + + virtual void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result) + {} + + virtual void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result) {} + virtual 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) + {} + + virtual void InternalClientUnload(int refnum, int int_ref, int* status, int* result) + {} }; /*! diff --git a/common/JackClient.cpp b/common/JackClient.cpp index 12ab8f9f..5f00254c 100644 --- a/common/JackClient.cpp +++ b/common/JackClient.cpp @@ -820,5 +820,61 @@ int JackClient::SetPortRegistrationCallback(JackPortRegistrationCallback callbac } } +//------------------ +// Internal clients +//------------------ + +char* JackClient::GetInternalClientName(int ref) +{ + // TODO + return ""; +} + +int JackClient::InternalClientHandle(const char* client_name, jack_status_t* status) +{ + int int_ref, result = -1; + fChannel->InternalClientHandle(GetClientControl()->fRefNum, client_name, (int*)status, &int_ref, &result); + return int_ref; +} + +int JackClient::InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va) +{ + if (strlen(client_name) >= JACK_CLIENT_NAME_SIZE) { + jack_error ("\"%s\" is too long for a JACK client name.\n" + "Please use %lu characters or less.", + client_name, JACK_CLIENT_NAME_SIZE); + return 0; + } + + if (va->load_name && (strlen(va->load_name) >= PATH_MAX)) { + jack_error("\"%s\" is too long for a shared object name.\n" + "Please use %lu characters or less.", + va->load_name, PATH_MAX); + int my_status1 = *status | (JackFailure | JackInvalidOption); + *status = (jack_status_t)my_status1; + return 0; + } + + if (va->load_init && (strlen(va->load_init) >= JACK_LOAD_INIT_LIMIT)) { + jack_error ("\"%s\" is too long for internal client init " + "string.\nPlease use %lu characters or less.", + va->load_init, JACK_LOAD_INIT_LIMIT); + int my_status1 = *status | (JackFailure | JackInvalidOption); + *status = (jack_status_t)my_status1; + return 0; + } + + int int_ref, result = -1; + fChannel->InternalClientLoad(GetClientControl()->fRefNum, client_name, va->load_name, va->load_init, options, (int*)status, &int_ref, &result); + return int_ref; +} + +void JackClient::InternalClientUnload(int ref, jack_status_t* status) +{ + int result = -1; + fChannel->InternalClientUnload(GetClientControl()->fRefNum, ref, (int*)status, &result); +} + + } // end of namespace diff --git a/common/JackClient.h b/common/JackClient.h index 590f4fab..e453996e 100644 --- a/common/JackClient.h +++ b/common/JackClient.h @@ -27,6 +27,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. #include "JackSynchro.h" #include "types.h" #include "transport_types.h" +#include "varargs.h" #include namespace Jack @@ -149,6 +150,12 @@ class JackClient : public JackClientInterface, public JackRunnableInterface virtual int SetClientRegistrationCallback(JackClientRegistrationCallback callback, void* arg); virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg); virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg); + + // Internal clients + virtual char* GetInternalClientName(int ref); + virtual int InternalClientHandle(const char* client_name, jack_status_t* status); + virtual int InternalClientLoad(const char* client_name, jack_options_t options, jack_status_t* status, jack_varargs_t* va); + virtual void InternalClientUnload(int ref, jack_status_t* status); // JackRunnableInterface interface bool Init(); diff --git a/common/JackEngine.cpp b/common/JackEngine.cpp index 5cb0e4f6..e2a66c38 100644 --- a/common/JackEngine.cpp +++ b/common/JackEngine.cpp @@ -28,6 +28,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. #include "JackEngine.h" #include "JackExternalClient.h" +#include "JackInternalClient.h" #include "JackEngineControl.h" #include "JackClientControl.h" #include "JackEngineTiming.h" @@ -88,7 +89,6 @@ int JackEngine::Close() JackClientInterface* client = fClientTable[i]; if (client) { JackLog("JackEngine::Close remaining client %ld\n", i); - ClientCloseAux(i, client, false); client->Close(); delete client; } @@ -373,6 +373,53 @@ void JackEngine::NotifyActivate(int refnum) NotifyClient(refnum, kActivateClient, true, 0); } +//---------------------------- +// Loadable client management +//---------------------------- + +int JackEngine::GetInternalClientName(int int_ref, char* name_res) +{ + JackClientInterface* client = fClientTable[int_ref]; + if (client) { + strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE); + return 0; + } else { + return -1; + } +} + +int JackEngine::InternalClientHandle(const char* client_name, int* status, int* int_ref) +{ + // Clear status + *status = 0; + + for (int i = 0; i < CLIENT_NUM; i++) { + JackClientInterface* client = fClientTable[i]; + if (client && dynamic_cast(client) && (strcmp(client->GetClientControl()->fName, client_name) == 0)) { + JackLog("InternalClientHandle found client name = %s ref = %ld\n", client_name, i); + *int_ref = i; + return 0; + } + } + + *status |= (JackNoSuchClient | JackFailure); + return -1; +} + +int JackEngine::InternalClientUnload(int refnum, int* status) +{ + JackClientInterface* client = fClientTable[refnum]; + if (client) { + int res = client->Close(); + delete client; + *status = 0; + return res; + } else { + *status = (JackNoSuchClient | JackFailure); + return -1; + } +} + //------------------- // Client management //------------------- @@ -384,8 +431,8 @@ int JackEngine::ClientCheck(const char* name, char* name_res, int protocol, int strcpy(name_res, name); if (protocol != JACK_PROTOCOL_VERSION) { - *status |= (JackFailure|JackVersionError); - jack_error ("JACK protocol mismatch (%d vs %d)", protocol, JACK_PROTOCOL_VERSION); + *status |= (JackFailure | JackVersionError); + jack_error("JACK protocol mismatch (%d vs %d)", protocol, JACK_PROTOCOL_VERSION); return -1; } diff --git a/common/JackEngine.h b/common/JackEngine.h index d4d2d5dc..d329821b 100644 --- a/common/JackEngine.h +++ b/common/JackEngine.h @@ -78,8 +78,7 @@ class JackEngine int Open(); int Close(); - - + // Client management int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status); int ClientExternalOpen(const char* name, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager); @@ -90,6 +89,11 @@ class JackEngine int ClientActivate(int refnum); int ClientDeactivate(int refnum); + + // Internal lient management + int GetInternalClientName(int int_ref, char* name_res); + int InternalClientHandle(const char* client_name, int* status, int* int_ref); + int InternalClientUnload(int refnum, int* status); // Port management int PortRegister(int refnum, const char* name, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index); diff --git a/common/JackInternalClient.cpp b/common/JackInternalClient.cpp index 8b8b87dc..9be0df90 100644 --- a/common/JackInternalClient.cpp +++ b/common/JackInternalClient.cpp @@ -116,5 +116,51 @@ JackClientControl* JackInternalClient::GetClientControl() const return fClientControl; } +JackLoadableInternalClient::JackLoadableInternalClient(JackServer* server, JackSynchro** table, const char* so_name, const char* object_data) + :JackInternalClient(server, table) +{ + char path_to_so[PATH_MAX + 1]; + //snprintf(path_to_so, sizeof(path_to_so), ADDON_DIR "/%s.so", so_name); + snprintf(path_to_so, sizeof(path_to_so), so_name); + snprintf(fObjectData, JACK_LOAD_INIT_LIMIT, object_data); + fHandle = LoadJackModule(path_to_so); + + printf("path_to_so %s\n", path_to_so); + + if (fHandle == 0) { + jack_error("error loading %s", so_name); + throw -1; + } + + fInitialize = (InitializeCallback)GetJackProc(fHandle, "jack_initialize"); + if (!fInitialize) { + UnloadJackModule(fHandle); + jack_error("symbol jack_initialize cannot be found in %s", so_name); + throw -1; + } + + fFinish = (FinishCallback)GetJackProc(fHandle, "jack_finish"); + if (!fFinish) { + UnloadJackModule(fHandle); + jack_error("symbol jack_finish cannot be found in %s", so_name); + throw -1; + } +} + +JackLoadableInternalClient::~JackLoadableInternalClient() +{ + if (fFinish) + fFinish(fProcessArg); + UnloadJackModule(fHandle); +} + +int JackLoadableInternalClient::Open(const char* name, jack_options_t options, jack_status_t* status) +{ + int res = JackInternalClient::Open(name, options, status); + if (res == 0) + fInitialize((jack_client_t*)this, fObjectData); + return res; +} + } // end of namespace diff --git a/common/JackInternalClient.h b/common/JackInternalClient.h index 183006d8..a5ed2af4 100644 --- a/common/JackInternalClient.h +++ b/common/JackInternalClient.h @@ -55,6 +55,51 @@ class JackInternalClient : public JackClient static JackEngineControl* fEngineControl; /*! Shared engine cotrol */ }; +/*! +\brief Loadable internal clients in the server. +*/ + +#ifdef WIN32 + +#include +#define HANDLE HINSTANCE +#define LoadJackModule(name) LoadLibrary((name)); +#define UnloadJackModule(handle) FreeLibrary((handle)); +#define GetJackProc(handle, name) GetProcAddress((handle), (name)); + +#else + +#include +#define HANDLE void* +#define LoadJackModule(name) dlopen((name), RTLD_NOW | RTLD_LOCAL); +#define UnloadJackModule(handle) dlclose((handle)); +#define GetJackProc(handle, name) dlsym((handle), (name)); + +#endif + +typedef int (*InitializeCallback)(jack_client_t*, const char*); +typedef void (*FinishCallback)(void *); + +class JackLoadableInternalClient : public JackInternalClient +{ + + private: + + HANDLE fHandle; + InitializeCallback fInitialize; + FinishCallback fFinish; + char fObjectData[JACK_LOAD_INIT_LIMIT]; + + public: + + JackLoadableInternalClient(JackServer* server, JackSynchro** table, const char* so_name, const char* object_data); + virtual ~JackLoadableInternalClient(); + + int Open(const char* name, jack_options_t options, jack_status_t* status); + +}; + + } // end of namespace #endif diff --git a/common/JackServer.cpp b/common/JackServer.cpp index f63cb59f..09c86397 100644 --- a/common/JackServer.cpp +++ b/common/JackServer.cpp @@ -35,6 +35,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. #include "JackEngineControl.h" #include "JackSyncInterface.h" #include "JackGraphManager.h" +#include "JackInternalClient.h" #ifdef __APPLE_ #include @@ -171,6 +172,29 @@ int JackServer::Close() return 0; } +int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status) +{ + try { + // Clear status + *status = 0; + JackLoadableInternalClient* client = new JackLoadableInternalClient(fInstance, GetSynchroTable(), so_name, objet_data); + assert(client); + int res = client->Open(client_name, (jack_options_t)options, (jack_status_t*)status); + if (res < 0) { + delete client; + *int_ref = 0; + } else { + *int_ref = client->GetClientControl()->fRefNum; + } + } catch (...) { + int my_status1 = *status | JackFailure; + *status = (jack_status_t)my_status1; + *int_ref = 0; + } + + return 0; +} + int JackServer::Start() { JackLog("JackServer::Start\n"); diff --git a/common/JackServer.h b/common/JackServer.h index f3af0efc..d2034d63 100644 --- a/common/JackServer.h +++ b/common/JackServer.h @@ -73,7 +73,9 @@ class EXPORT JackServer int SetBufferSize(jack_nframes_t buffer_size); int SetFreewheel(bool onoff); void Notify(int refnum, int notify, int value); - + + int InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status); + JackEngine* GetEngine(); JackEngineControl* GetEngineControl(); JackSynchro** GetSynchroTable(); diff --git a/common/JackServerAPI.cpp b/common/JackServerAPI.cpp index 2749e66f..355bec5a 100644 --- a/common/JackServerAPI.cpp +++ b/common/JackServerAPI.cpp @@ -41,7 +41,7 @@ extern "C" { #endif - EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name); + EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name, const char* dll_name, const char* object_data); EXPORT void my_jack_internal_client_close(jack_client_t* ext_client); EXPORT jack_client_t * jack_client_open (const char *client_name, @@ -56,21 +56,30 @@ extern "C" using namespace Jack; -EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name) +EXPORT jack_client_t* my_jack_internal_client_new(const char* client_name, const char* dll_name, const char* object_data) { + jack_status_t my_status = (jack_status_t)0; + JackLog("jack_internal_client_new %s", client_name); if (client_name == NULL) { jack_error("jack_internal_client_new called with a NULL client_name"); return NULL; } -#ifdef __CLIENTDEBUG__ - JackClient* client = new JackDebugClient(new JackInternalClient(JackServer::fInstance, GetSynchroTable())); // Debug mode -#else - JackClient* client = new JackInternalClient(JackServer::fInstance, GetSynchroTable()); // To improve... -#endif + + JackClient* client; + + try { + #ifdef __CLIENTDEBUG__ + client = new JackDebugClient(new JackLoadableInternalClient(JackServer::fInstance, GetSynchroTable(), dll_name, object_data)); // Debug mode + #else + client = new JackLoadableInternalClient(JackServer::fInstance, GetSynchroTable(), dll_name, object_data); // To improve... + #endif + } catch (...) { // Allocation or dynamic code loading failure + return NULL; + } jack_options_t options = JackUseExactName; - int res = client->Open(client_name, options, NULL); + int res = client->Open(client_name, options, &my_status); if (res < 0) { delete client; return NULL; diff --git a/common/Jackdmp.cpp b/common/Jackdmp.cpp index b573f363..4624a361 100644 --- a/common/Jackdmp.cpp +++ b/common/Jackdmp.cpp @@ -458,6 +458,14 @@ int main(int argc, char* argv[]) JackDelete(); return 0; } + + /* + jack_client_t* c1 = my_jack_internal_client_new("c1", "inprocess.so", "untitled"); + jack_client_t* c2 = my_jack_internal_client_new("c2", "inprocess.so", "untitled"); + jack_client_t* c3 = my_jack_internal_client_new("c3", "inprocess.so", "untitled"); + jack_client_t* c4 = my_jack_internal_client_new("c4", "inprocess.so", "untitled"); + jack_client_t* c5 = my_jack_internal_client_new("c5", "inprocess.so", "untitled"); + */ /* For testing purpose... @@ -514,7 +522,15 @@ int main(int argc, char* argv[]) // bugs that cause segfaults etc. during shutdown. sigprocmask(SIG_UNBLOCK, &signals, 0); } - + + /* + my_jack_internal_client_close(c1); + my_jack_internal_client_close(c2); + my_jack_internal_client_close(c3); + my_jack_internal_client_close(c4); + my_jack_internal_client_close(c5); + */ + JackStop(); jack_cleanup_shm(); diff --git a/common/jack.h b/common/jack.h index 2c72b3c2..07afa386 100644 --- a/common/jack.h +++ b/common/jack.h @@ -152,7 +152,7 @@ extern "C" const char *load_name, const char *load_init); - jack_client_t* my_jack_internal_client_new(const char* client_name); + jack_client_t* my_jack_internal_client_new(const char* client_name, const char* dll_name, const char* object_data); /** * Remove an internal client from a JACK server. diff --git a/example-clients/inprocess.c b/example-clients/inprocess.c new file mode 100644 index 00000000..c650f415 --- /dev/null +++ b/example-clients/inprocess.c @@ -0,0 +1,123 @@ +/** @file inprocess.c + * + * @brief This demonstrates the basic concepts for writing a client + * that runs within the JACK server process. + * + * For the sake of example, a port_pair_t is allocated in + * jack_initialize(), passed to inprocess() as an argument, then freed + * in jack_finish(). + */ + +#include +#include +#include +#include + +/** + * For the sake of example, an instance of this struct is allocated in + * jack_initialize(), passed to inprocess() as an argument, then freed + * in jack_finish(). + */ +typedef struct { + jack_port_t *input_port; + jack_port_t *output_port; +} port_pair_t; + +/** + * Called in the realtime thread on every process cycle. The entry + * point name was passed to jack_set_process_callback() from + * jack_initialize(). Although this is an internal client, its + * process() interface is identical to @ref simple_client.c. + * + * @return 0 if successful; otherwise jack_finish() will be called and + * the client terminated immediately. + */ +int +inprocess (jack_nframes_t nframes, void *arg) +{ + port_pair_t *pp = arg; + jack_default_audio_sample_t *out = + jack_port_get_buffer (pp->output_port, nframes); + jack_default_audio_sample_t *in = + jack_port_get_buffer (pp->input_port, nframes); + + memcpy (out, in, sizeof (jack_default_audio_sample_t) * nframes); + + return 0; /* continue */ +} + +/** + * This required entry point is called after the client is loaded by + * jack_internal_client_load(). + * + * @param client pointer to JACK client structure. + * @param load_init character string passed to the load operation. + * + * @return 0 if successful; otherwise jack_finish() will be called and + * the client terminated immediately. + */ +int +jack_initialize (jack_client_t *client, const char *load_init) +{ + port_pair_t *pp = malloc (sizeof (port_pair_t)); + const char **ports; + + if (pp == NULL) + return 1; /* heap exhausted */ + + jack_set_process_callback (client, inprocess, pp); + + /* create a pair of ports */ + pp->input_port = jack_port_register (client, "input", + JACK_DEFAULT_AUDIO_TYPE, + JackPortIsInput, 0); + pp->output_port = jack_port_register (client, "output", + JACK_DEFAULT_AUDIO_TYPE, + JackPortIsOutput, 0); + + /* join the process() cycle */ + jack_activate (client); + + ports = jack_get_ports (client, NULL, NULL, + JackPortIsPhysical|JackPortIsOutput); + if (ports == NULL) { + fprintf(stderr, "no physical capture ports\n"); + return 1; /* terminate client */ + } + + if (jack_connect (client, ports[0], jack_port_name (pp->input_port))) { + fprintf (stderr, "cannot connect input ports\n"); + } + + free (ports); + + ports = jack_get_ports (client, NULL, NULL, + JackPortIsPhysical|JackPortIsInput); + if (ports == NULL) { + fprintf(stderr, "no physical playback ports\n"); + return 1; /* terminate client */ + } + + if (jack_connect (client, jack_port_name (pp->output_port), ports[0])) { + fprintf (stderr, "cannot connect output ports\n"); + } + + free (ports); + + return 0; /* success */ +} + +/** + * This required entry point is called immediately before the client + * is unloaded, which could happen due to a call to + * jack_internal_client_unload(), or a nonzero return from either + * jack_initialize() or inprocess(). + * + * @param arg the same parameter provided to inprocess(). + */ +void +jack_finish (void *arg) +{ + if (arg) + free ((port_pair_t *) arg); +} diff --git a/example-clients/ipload.c b/example-clients/ipload.c new file mode 100644 index 00000000..b433aa59 --- /dev/null +++ b/example-clients/ipload.c @@ -0,0 +1,171 @@ +#include +#include +#include +#include +#include +#include + +#include "jack.h" +#include "intclient.h" + +jack_client_t *client; +jack_intclient_t intclient; +char *client_name; +char *intclient_name; +char *load_name; +char *load_init = ""; +char *server_name = NULL; +int wait_opt = 0; + +void +signal_handler (int sig) +{ + jack_status_t status; + + fprintf (stderr, "signal received, unloading..."); + status = jack_internal_client_unload (client, intclient); + if (status & JackFailure) + fprintf (stderr, "(failed), status = 0x%2.0x\n", status); + else + fprintf (stderr, "(succeeded)\n"); + jack_client_close (client); + exit (0); +} + +void +show_usage () +{ + fprintf (stderr, "usage: %s [ options ] client-name [ load-name " + "[ init-string]]\n\noptions:\n", client_name); + fprintf (stderr, + "\t-h, --help \t\t print help message\n" + "\t-i, --init string\t initialize string\n" + "\t-s, --server name\t select JACK server\n" + "\t-w, --wait \t\t wait for signal, then unload\n" + "\n" + ); +} + +int +parse_args (int argc, char *argv[]) +{ + int c; + int option_index = 0; + char *short_options = "hi:s:w"; + struct option long_options[] = { + { "help", 0, 0, 'h' }, + { "init", required_argument, 0, 'i' }, + { "server", required_argument, 0, 's' }, + { "wait", 0, 0, 'w' }, + { 0, 0, 0, 0 } + }; + + client_name = strrchr(argv[0], '/'); + if (client_name == NULL) { + client_name = argv[0]; + } else { + client_name++; + } + + while ((c = getopt_long (argc, argv, short_options, long_options, + &option_index)) >= 0) { + switch (c) { + case 'i': + load_init = optarg; + break; + case 's': + server_name = optarg; + break; + case 'w': + wait_opt = 1; + break; + case 'h': + default: + show_usage (); + return 1; + } + } + + if (optind == argc) { /* no positional args? */ + show_usage (); + return 1; + } + if (optind < argc) + load_name = intclient_name = argv[optind++]; + + if (optind < argc) + load_name = argv[optind++]; + + if (optind < argc) + load_init = argv[optind++]; + + //fprintf (stderr, "client-name = `%s', load-name = `%s', " + // "load-init = `%s', wait = %d\n", + // intclient_name, load_name, load_init, wait_opt); + + return 0; /* args OK */ +} + +int +main (int argc, char *argv[]) +{ + jack_status_t status; + + /* parse and validate command arguments */ + if (parse_args (argc, argv)) + exit (1); /* invalid command line */ + + /* first, become a JACK client */ + client = jack_client_open (client_name, JackServerName, + &status, server_name); + if (client == NULL) { + fprintf (stderr, "jack_client_open() failed, " + "status = 0x%2.0x\n", status); + if (status & JackServerFailed) { + fprintf (stderr, "Unable to connect to JACK server\n"); + } + exit (1); + } + if (status & JackServerStarted) { + fprintf (stderr, "JACK server started\n"); + } + if (status & JackNameNotUnique) { + client_name = jack_get_client_name(client); + fprintf (stderr, "unique name `%s' assigned\n", client_name); + } + + /* then, load the internal client */ + intclient = jack_internal_client_load (client, intclient_name, + (JackLoadName|JackLoadInit), + &status, load_name, load_init); + if (status & JackFailure) { + fprintf (stderr, "could not load %s, status = 0x%2.0x\n", + load_name, status); + return 2; + } + if (status & JackNameNotUnique) { + intclient_name = + jack_get_internal_client_name (client, intclient); + fprintf (stderr, "unique internal client name `%s' assigned\n", + intclient_name); + } + + fprintf (stdout, "%s is running.\n", load_name); + + if (wait_opt) { + /* define a signal handler to unload the client, then + * wait for it to exit */ + signal (SIGQUIT, signal_handler); + signal (SIGTERM, signal_handler); + signal (SIGHUP, signal_handler); + signal (SIGINT, signal_handler); + + while (1) { + sleep (1); + } + } + + return 0; +} + + diff --git a/example-clients/ipunload.c b/example-clients/ipunload.c new file mode 100644 index 00000000..442fce71 --- /dev/null +++ b/example-clients/ipunload.c @@ -0,0 +1,77 @@ +#include +#include +#include + +#include "jack.h" +#include "intclient.h" + +int +main (int argc, char *argv[]) +{ + char *my_name; + char *client_name; + jack_client_t *client; + jack_status_t status; + jack_intclient_t intclient; + + /* validate args */ + if ((argc < 2) || (argc > 3)) { + fprintf (stderr, "usage: %s client-name [ server-name ]]\n", + argv[0]); + return 1; + } + + /* use `basename $0` for my own client name */ + my_name = strrchr(argv[0], '/'); + if (my_name == 0) { + my_name = argv[0]; + } else { + my_name++; + } + + /* first, become a JACK client */ + if (argc > 2) { + client = jack_client_open (my_name, + (JackServerName|JackNoStartServer), + &status, argv[2]); + } else { + client = jack_client_open (my_name, JackNoStartServer, &status); + } + + if (client == NULL) { + if (status & JackServerFailed) { + fprintf (stderr, "JACK server not running.\n"); + } else { + fprintf (stderr, "JACK open failed, " + "status = 0x%2.0x\n", status); + } + exit (1); + } + + /* then, get the internal client handle */ + client_name = argv[1]; + intclient = jack_internal_client_handle (client, client_name, &status); + if (status & JackFailure) { + fprintf (stderr, "client %s not found.\n", client_name); + exit (2); + } + + /* now, unload the internal client */ + status = jack_internal_client_unload (client, intclient); + if (status & JackFailure) { + if (status & JackNoSuchClient) { + fprintf (stderr, "client %s is gone.\n", + client_name); + } else { + fprintf (stderr, "could not unload %s, " + "returns 0x%2.0x\n", client_name, status); + } + exit (3); + } else { + fprintf (stdout, "%s unloaded.\n", client_name); + } + + return 0; +} + + diff --git a/macosx/JackMacEngineRPC.cpp b/macosx/JackMacEngineRPC.cpp index 0ad7451b..4394ce5b 100644 --- a/macosx/JackMacEngineRPC.cpp +++ b/macosx/JackMacEngineRPC.cpp @@ -179,6 +179,46 @@ rpc_type server_rpc_jack_set_timebase_callback(mach_port_t private_port, int ref 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) +{ + JackLog("server_rpc_jack_get_internal_clientname\n"); + 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) +{ + JackLog("server_rpc_jack_internal_clienthandle\n"); + 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) +{ + JackLog("server_rpc_jack_internal_clientload\n"); + 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) +{ + JackLog("server_rpc_jack_internal_clientunload\n"); + JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port]; + assert(channel); + *result = channel->GetServer()->GetEngine()->InternalClientUnload(int_ref, status); + return KERN_SUCCESS; +} + //----------------- // RT notification //----------------- diff --git a/macosx/JackMachClientChannel.cpp b/macosx/JackMachClientChannel.cpp index 947cf155..d3520805 100644 --- a/macosx/JackMachClientChannel.cpp +++ b/macosx/JackMachClientChannel.cpp @@ -254,6 +254,42 @@ void JackMachClientChannel::SetTimebaseCallback(int refnum, int conditional, int } } +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) +{ + kern_return_t res = rpc_jack_internal_clientload(fPrivatePort, refnum, (char*)client_name, (char*)so_name, (char*)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::Execute() { kern_return_t res; diff --git a/macosx/JackMachClientChannel.h b/macosx/JackMachClientChannel.h index 0411798a..e585a471 100644 --- a/macosx/JackMachClientChannel.h +++ b/macosx/JackMachClientChannel.h @@ -77,7 +77,12 @@ class JackMachClientChannel : public JackClientChannelInterface, public JackRunn 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 Execute(); }; diff --git a/macosx/Jackdmp.xcodeproj/project.pbxproj b/macosx/Jackdmp.xcodeproj/project.pbxproj index 6caf58ad..1c20f153 100644 --- a/macosx/Jackdmp.xcodeproj/project.pbxproj +++ b/macosx/Jackdmp.xcodeproj/project.pbxproj @@ -20,6 +20,7 @@ 4B699DBA097D421700A18468 /* PBXTargetDependency */, 4B699DBC097D421700A18468 /* PBXTargetDependency */, 4B978E800A31D8B7009E2DD1 /* PBXTargetDependency */, + 4BD624D30CBCF55700DE782F /* PBXTargetDependency */, 4BFA99440AAAED90009E916C /* PBXTargetDependency */, 4BFA99460AAAED90009E916C /* PBXTargetDependency */, 4BFA99480AAAED90009E916C /* PBXTargetDependency */, @@ -28,6 +29,8 @@ 4BFA994E0AAAED90009E916C /* PBXTargetDependency */, 4BFA99560AAAED90009E916C /* PBXTargetDependency */, 4BE99D630AD7A19100C59091 /* PBXTargetDependency */, + 4BA693E90CBE5BBA00EAD520 /* PBXTargetDependency */, + 4BA693EB0CBE5BBA00EAD520 /* PBXTargetDependency */, 4BFA99AC0AAAF41D009E916C /* PBXTargetDependency */, 4BFA99500AAAED90009E916C /* PBXTargetDependency */, 4BFA99520AAAED90009E916C /* PBXTargetDependency */, @@ -248,6 +251,8 @@ 4B699DAA097D421700A18468 /* JackDummyDriver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3988908B3CF6C00B6F371 /* JackDummyDriver.cpp */; }; 4B978DED0A31D099009E2DD1 /* JackPortAudioDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4B978DEB0A31D099009E2DD1 /* JackPortAudioDriver.h */; }; 4B978DEE0A31D099009E2DD1 /* JackPortAudioDriver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B978DEC0A31D099009E2DD1 /* JackPortAudioDriver.cpp */; }; + 4BA692B30CBE4C2D00EAD520 /* ipload.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BA692B20CBE4C2D00EAD520 /* ipload.c */; }; + 4BA692D70CBE4CC600EAD520 /* ipunload.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BA692D60CBE4CC600EAD520 /* ipunload.c */; }; 4BC216850A444BAD00BDA09F /* JackServerAPI.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BF8D1F50834EFB000C94B91 /* JackServerAPI.cpp */; }; 4BC216890A444BDE00BDA09F /* JackServerGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC216880A444BDE00BDA09F /* JackServerGlobals.cpp */; }; 4BC2168E0A444BED00BDA09F /* JackServerGlobals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BC2168D0A444BED00BDA09F /* JackServerGlobals.h */; }; @@ -255,6 +260,7 @@ 4BD4B4D909BACD9600750C0F /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; }; 4BD4B4E409BACEF300750C0F /* JackTransportEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */; }; 4BD4B4E509BACEF300750C0F /* JackTransportEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BD4B4D409BACD9600750C0F /* JackTransportEngine.h */; }; + 4BD6240D0CBCF16600DE782F /* inprocess.c in Sources */ = {isa = PBXBuildFile; fileRef = 4BD6240C0CBCF16600DE782F /* inprocess.c */; }; 4BE50F960B01EEC400C05E63 /* JackAPIWrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE50F650B01E96200C05E63 /* JackAPIWrapper.cpp */; }; 4BE6C6AD0A3E0A65005A203A /* jack_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BE6C6AC0A3E0A65005A203A /* jack_test.cpp */; }; 4BF5202B0CB8CF610037470E /* intclient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4BF5202A0CB8CF610037470E /* intclient.h */; settings = {ATTRIBUTES = (Public, ); }; }; @@ -330,6 +336,27 @@ remoteGlobalIDString = 4B978DB10A31CF4A009E2DD1; remoteInfo = "jack_portaudio Universal"; }; + 4BA693E80CBE5BBA00EAD520 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 4BA692A60CBE4BC700EAD520 /* jack_load Universal */; + remoteInfo = "jack_load Universal"; + }; + 4BA693EA0CBE5BBA00EAD520 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 4BA692CA0CBE4C9000EAD520 /* jack_unload Universal */; + remoteInfo = "jack_unload Universal"; + }; + 4BD624D20CBCF55700DE782F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 4BD623ED0CBCF0F000DE782F; + remoteInfo = inprocess; + }; 4BE50F9C0B01EEE500C05E63 /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 08FB7793FE84155DC02AAC07 /* Project object */; @@ -454,7 +481,6 @@ 4B37C20306DF1FBE0016E567 /* CALatencyLog.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CALatencyLog.cpp; path = /Developer/Examples/CoreAudio/PublicUtility/CALatencyLog.cpp; sourceTree = ""; }; 4B37C20406DF1FBE0016E567 /* CALatencyLog.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CALatencyLog.h; path = /Developer/Examples/CoreAudio/PublicUtility/CALatencyLog.h; sourceTree = ""; }; 4B37C20906DF1FE20016E567 /* latency.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = latency.c; path = /Developer/Examples/CoreAudio/PublicUtility/latency.c; sourceTree = ""; }; - 4B37C20A06DF1FE20016E567 /* latency.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = latency.h; path = /Developer/Examples/CoreAudio/PublicUtility/latency.h; sourceTree = ""; }; 4B395C9606AEF53800923527 /* JackCoreAudioDriver.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JackCoreAudioDriver.cpp; sourceTree = SOURCE_ROOT; }; 4B395C9706AEF53800923527 /* JackCoreAudioDriver.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JackCoreAudioDriver.h; sourceTree = SOURCE_ROOT; }; 4B3F49070AD8503300491C6E /* jack_cpu.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = jack_cpu.c; path = ../tests/jack_cpu.c; sourceTree = SOURCE_ROOT; }; @@ -510,6 +536,10 @@ 4B9B815C08AFA45000D05A28 /* JackRequest.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackRequest.h; path = ../common/JackRequest.h; sourceTree = SOURCE_ROOT; }; 4BA577BC08BF8BE200F82DE1 /* testSynchroClient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testSynchroClient.cpp; path = ../tests/testSynchroClient.cpp; sourceTree = SOURCE_ROOT; }; 4BA577FB08BF8E4600F82DE1 /* testSynchroServer.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testSynchroServer.cpp; path = ../tests/testSynchroServer.cpp; sourceTree = SOURCE_ROOT; }; + 4BA692B00CBE4BC700EAD520 /* jack_load */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_load; sourceTree = BUILT_PRODUCTS_DIR; }; + 4BA692B20CBE4C2D00EAD520 /* ipload.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = ipload.c; path = "../example-clients/ipload.c"; sourceTree = SOURCE_ROOT; }; + 4BA692D40CBE4C9000EAD520 /* jack_unload */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = jack_unload; sourceTree = BUILT_PRODUCTS_DIR; }; + 4BA692D60CBE4CC600EAD520 /* ipunload.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = ipunload.c; path = "../example-clients/ipunload.c"; sourceTree = SOURCE_ROOT; }; 4BB371D40C1AD85A0050C1E4 /* JackNotification.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackNotification.h; path = ../common/JackNotification.h; sourceTree = SOURCE_ROOT; }; 4BBD13CC08C71EB40079F7FF /* testSynchroServerClient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testSynchroServerClient.cpp; path = ../tests/testSynchroServerClient.cpp; sourceTree = SOURCE_ROOT; }; 4BC216880A444BDE00BDA09F /* JackServerGlobals.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackServerGlobals.cpp; path = ../common/JackServerGlobals.cpp; sourceTree = SOURCE_ROOT; }; @@ -519,6 +549,8 @@ 4BD4B4D409BACD9600750C0F /* JackTransportEngine.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackTransportEngine.h; path = ../common/JackTransportEngine.h; sourceTree = SOURCE_ROOT; }; 4BD4B4D509BACD9600750C0F /* JackTransportEngine.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackTransportEngine.cpp; path = ../common/JackTransportEngine.cpp; sourceTree = SOURCE_ROOT; }; 4BD561C708EEB910006BBC2A /* JackSynchro.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = JackSynchro.h; path = ../common/JackSynchro.h; sourceTree = SOURCE_ROOT; }; + 4BD623F70CBCF0F000DE782F /* inprocess.so */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.dylib"; includeInIndex = 0; path = inprocess.so; sourceTree = BUILT_PRODUCTS_DIR; }; + 4BD6240C0CBCF16600DE782F /* inprocess.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = inprocess.c; path = "../example-clients/inprocess.c"; sourceTree = SOURCE_ROOT; }; 4BE50F650B01E96200C05E63 /* JackAPIWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = JackAPIWrapper.cpp; path = ../common/JackAPIWrapper.cpp; sourceTree = SOURCE_ROOT; }; 4BE50F8E0B01EE8000C05E63 /* Jackwrapper.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Jackwrapper.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 4BE50F8F0B01EE8000C05E63 /* Jackwrapper-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = "Jackwrapper-Info.plist"; sourceTree = ""; }; @@ -745,6 +777,27 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 4BA692AA0CBE4BC700EAD520 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BA692CE0CBE4C9000EAD520 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BD623F20CBCF0F000DE782F /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; 4BE50F8C0B01EE8000C05E63 /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; @@ -842,6 +895,9 @@ 4BFA99A20AAAF3B0009E916C /* jdelay */, 4BE99D300AD7A04800C59091 /* jack_cpu */, 4BE50F8E0B01EE8000C05E63 /* Jackwrapper.framework */, + 4BD623F70CBCF0F000DE782F /* inprocess.so */, + 4BA692B00CBE4BC700EAD520 /* jack_load */, + 4BA692D40CBE4C9000EAD520 /* jack_unload */, ); name = Products; sourceTree = ""; @@ -849,6 +905,9 @@ 4B03383E0797E19900686131 /* Simple clients */ = { isa = PBXGroup; children = ( + 4BA692D60CBE4CC600EAD520 /* ipunload.c */, + 4BA692B20CBE4C2D00EAD520 /* ipload.c */, + 4BD6240C0CBCF16600DE782F /* inprocess.c */, 4B60CE480AAABA31004956AA /* connect.c */, 4BF8D1670834EDD900C94B91 /* zombie.c */, 4BF8D1690834EDE600C94B91 /* lsp.c */, @@ -882,7 +941,6 @@ isa = PBXGroup; children = ( 4B37C20906DF1FE20016E567 /* latency.c */, - 4B37C20A06DF1FE20016E567 /* latency.h */, 4B37C20306DF1FBE0016E567 /* CALatencyLog.cpp */, 4B37C20406DF1FBE0016E567 /* CALatencyLog.h */, ); @@ -1408,6 +1466,27 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 4BA692A70CBE4BC700EAD520 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BA692CB0CBE4C9000EAD520 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BD623EE0CBCF0F000DE782F /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; 4BE50F890B01EE8000C05E63 /* Headers */ = { isa = PBXHeadersBuildPhase; buildActionMask = 2147483647; @@ -1780,6 +1859,61 @@ productReference = 4B978DBB0A31CF4A009E2DD1 /* jack_portaudio.so */; productType = "com.apple.product-type.library.dynamic"; }; + 4BA692A60CBE4BC700EAD520 /* jack_load Universal */ = { + isa = PBXNativeTarget; + buildConfigurationList = 4BA692AC0CBE4BC700EAD520 /* Build configuration list for PBXNativeTarget "jack_load Universal" */; + buildPhases = ( + 4BA692A70CBE4BC700EAD520 /* Headers */, + 4BA692A80CBE4BC700EAD520 /* Sources */, + 4BA692AA0CBE4BC700EAD520 /* Frameworks */, + 4BA692AB0CBE4BC700EAD520 /* Rez */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "jack_load Universal"; + productInstallPath = /usr/local/bin; + productName = testSem; + productReference = 4BA692B00CBE4BC700EAD520 /* jack_load */; + productType = "com.apple.product-type.tool"; + }; + 4BA692CA0CBE4C9000EAD520 /* jack_unload Universal */ = { + isa = PBXNativeTarget; + buildConfigurationList = 4BA692D00CBE4C9000EAD520 /* Build configuration list for PBXNativeTarget "jack_unload Universal" */; + buildPhases = ( + 4BA692CB0CBE4C9000EAD520 /* Headers */, + 4BA692CC0CBE4C9000EAD520 /* Sources */, + 4BA692CE0CBE4C9000EAD520 /* Frameworks */, + 4BA692CF0CBE4C9000EAD520 /* Rez */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "jack_unload Universal"; + productInstallPath = /usr/local/bin; + productName = testSem; + productReference = 4BA692D40CBE4C9000EAD520 /* jack_unload */; + productType = "com.apple.product-type.tool"; + }; + 4BD623ED0CBCF0F000DE782F /* inprocess */ = { + isa = PBXNativeTarget; + buildConfigurationList = 4BD623F30CBCF0F000DE782F /* Build configuration list for PBXNativeTarget "inprocess" */; + buildPhases = ( + 4BD623EE0CBCF0F000DE782F /* Headers */, + 4BD623F00CBCF0F000DE782F /* Sources */, + 4BD623F20CBCF0F000DE782F /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = inprocess; + productName = jack_coreaudio; + productReference = 4BD623F70CBCF0F000DE782F /* inprocess.so */; + productType = "com.apple.product-type.library.dynamic"; + }; 4BE50F8D0B01EE8000C05E63 /* Jackwrapper.framework Universal */ = { isa = PBXNativeTarget; buildConfigurationList = 4BE50F900B01EE8100C05E63 /* Build configuration list for PBXNativeTarget "Jackwrapper.framework Universal" */; @@ -1882,12 +2016,15 @@ 4B699D3F097D421600A18468 /* zombie Universal */, 4BE6C6910A3E096F005A203A /* jack_test Universal */, 4BE99D260AD7A04800C59091 /* jack_cpu Universal */, + 4BA692A60CBE4BC700EAD520 /* jack_load Universal */, + 4BA692CA0CBE4C9000EAD520 /* jack_unload Universal */, 4B699D4F097D421600A18468 /* synchroServer Universal */, 4B699D67097D421600A18468 /* synchroClient Universal */, 4B699D7F097D421700A18468 /* synchroServerClient Universal */, 4B699D97097D421700A18468 /* jack_coreaudio Universal */, 4B978DB10A31CF4A009E2DD1 /* jack_portaudio Universal */, 4B699DA6097D421700A18468 /* jack_dummy Universal */, + 4BD623ED0CBCF0F000DE782F /* inprocess */, ); }; /* End PBXProject section */ @@ -2022,6 +2159,20 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 4BA692AB0CBE4BC700EAD520 /* Rez */ = { + isa = PBXRezBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BA692CF0CBE4C9000EAD520 /* Rez */ = { + isa = PBXRezBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; 4BE6C69E0A3E096F005A203A /* Rez */ = { isa = PBXRezBuildPhase; buildActionMask = 2147483647; @@ -2291,6 +2442,30 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 4BA692A80CBE4BC700EAD520 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 4BA692B30CBE4C2D00EAD520 /* ipload.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BA692CC0CBE4C9000EAD520 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 4BA692D70CBE4CC600EAD520 /* ipunload.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 4BD623F00CBCF0F000DE782F /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 4BD6240D0CBCF16600DE782F /* inprocess.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; 4BE50F8B0B01EE8000C05E63 /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; @@ -2361,6 +2536,21 @@ target = 4B978DB10A31CF4A009E2DD1 /* jack_portaudio Universal */; targetProxy = 4B978E7F0A31D8B7009E2DD1 /* PBXContainerItemProxy */; }; + 4BA693E90CBE5BBA00EAD520 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 4BA692A60CBE4BC700EAD520 /* jack_load Universal */; + targetProxy = 4BA693E80CBE5BBA00EAD520 /* PBXContainerItemProxy */; + }; + 4BA693EB0CBE5BBA00EAD520 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 4BA692CA0CBE4C9000EAD520 /* jack_unload Universal */; + targetProxy = 4BA693EA0CBE5BBA00EAD520 /* PBXContainerItemProxy */; + }; + 4BD624D30CBCF55700DE782F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 4BD623ED0CBCF0F000DE782F /* inprocess */; + targetProxy = 4BD624D20CBCF55700DE782F /* PBXContainerItemProxy */; + }; 4BE50F9D0B01EEE500C05E63 /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 4BE50F8D0B01EE8000C05E63 /* Jackwrapper.framework Universal */; @@ -4510,6 +4700,317 @@ }; name = Default; }; + 4BA692AD0CBE4BC700EAD520 /* Development */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_load; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = YES; + }; + name = Development; + }; + 4BA692AE0CBE4BC700EAD520 /* Deployment */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_OPTIMIZATION_LEVEL = 3; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_load; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = NO; + }; + name = Deployment; + }; + 4BA692AF0CBE4BC700EAD520 /* Default */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_OPTIMIZATION_LEVEL = 3; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_load; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + }; + name = Default; + }; + 4BA692D10CBE4C9000EAD520 /* Development */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_unload; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = YES; + }; + name = Development; + }; + 4BA692D20CBE4C9000EAD520 /* Deployment */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_OPTIMIZATION_LEVEL = 3; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_unload; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = NO; + }; + name = Deployment; + }; + 4BA692D30CBE4C9000EAD520 /* Default */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_OPTIMIZATION_LEVEL = 3; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ( + "-framework", + Jackmp, + ); + OTHER_REZFLAGS = ""; + PRODUCT_NAME = jack_unload; + REZ_EXECUTABLE = YES; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + }; + name = Default; + }; + 4BD623F40CBCF0F000DE782F /* Development */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = NO; + DEBUGGING_SYMBOLS = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + EXECUTABLE_EXTENSION = so; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G4; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ""; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = DYNAMIC; + MACH_O_TYPE = mh_dylib; + OPTIMIZATION_CFLAGS = "-O0"; + OTHER_CFLAGS = ""; + OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)"; + OTHER_LDFLAGS = ( + "-framework", + Jackdmp, + "-framework", + AudioToolBox, + "-framework", + CoreAudio, + "-framework", + CoreServices, + "-framework", + AudioUnit, + ); + OTHER_REZFLAGS = ""; + PREBINDING = NO; + PRODUCT_NAME = inprocess; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = YES; + }; + name = Development; + }; + 4BD623F50CBCF0F000DE782F /* Deployment */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + COPY_PHASE_STRIP = YES; + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + EXECUTABLE_EXTENSION = so; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G4; + GCC_PREPROCESSOR_DEFINITIONS = ""; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = DYNAMIC; + MACH_O_TYPE = mh_dylib; + OTHER_CFLAGS = ""; + OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)"; + OTHER_LDFLAGS = ( + "-framework", + Jackdmp, + "-framework", + AudioToolBox, + "-framework", + CoreAudio, + "-framework", + CoreServices, + "-framework", + AudioUnit, + ); + OTHER_REZFLAGS = ""; + PREBINDING = NO; + PRODUCT_NAME = inprocess; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + ZERO_LINK = NO; + }; + name = Deployment; + }; + 4BD623F60CBCF0F000DE782F /* Default */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + DYLIB_COMPATIBILITY_VERSION = 1; + DYLIB_CURRENT_VERSION = 1; + EXECUTABLE_EXTENSION = so; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G4; + GCC_PREPROCESSOR_DEFINITIONS = ""; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = DYNAMIC; + MACH_O_TYPE = mh_dylib; + OTHER_CFLAGS = ""; + OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)"; + OTHER_LDFLAGS = ( + "-framework", + Jackdmp, + "-framework", + AudioToolBox, + "-framework", + CoreAudio, + "-framework", + CoreServices, + "-framework", + AudioUnit, + ); + OTHER_REZFLAGS = ""; + PREBINDING = NO; + PRODUCT_NAME = inprocess; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + }; + name = Default; + }; 4BE50F910B01EE8100C05E63 /* Development */ = { isa = XCBuildConfiguration; buildSettings = { @@ -5059,6 +5560,36 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Default; }; + 4BA692AC0CBE4BC700EAD520 /* Build configuration list for PBXNativeTarget "jack_load Universal" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 4BA692AD0CBE4BC700EAD520 /* Development */, + 4BA692AE0CBE4BC700EAD520 /* Deployment */, + 4BA692AF0CBE4BC700EAD520 /* Default */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Default; + }; + 4BA692D00CBE4C9000EAD520 /* Build configuration list for PBXNativeTarget "jack_unload Universal" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 4BA692D10CBE4C9000EAD520 /* Development */, + 4BA692D20CBE4C9000EAD520 /* Deployment */, + 4BA692D30CBE4C9000EAD520 /* Default */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Default; + }; + 4BD623F30CBCF0F000DE782F /* Build configuration list for PBXNativeTarget "inprocess" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 4BD623F40CBCF0F000DE782F /* Development */, + 4BD623F50CBCF0F000DE782F /* Deployment */, + 4BD623F60CBCF0F000DE782F /* Default */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Default; + }; 4BE50F900B01EE8100C05E63 /* Build configuration list for PBXNativeTarget "Jackwrapper.framework Universal" */ = { isa = XCConfigurationList; buildConfigurations = ( diff --git a/macosx/RPC/JackRPCClientServer.c b/macosx/RPC/JackRPCClientServer.c index c0811e99..3fcd8493 100644 --- a/macosx/RPC/JackRPCClientServer.c +++ b/macosx/RPC/JackRPCClientServer.c @@ -1,6 +1,6 @@ /* * IDENTIFICATION: - * stub generated Mon Aug 27 17:58:23 2007 + * stub generated Thu Oct 11 16:40:18 2007 * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com * OPTIONS: */ diff --git a/macosx/RPC/JackRPCClientUser.c b/macosx/RPC/JackRPCClientUser.c index 96d9bd90..d8c7e1c1 100644 --- a/macosx/RPC/JackRPCClientUser.c +++ b/macosx/RPC/JackRPCClientUser.c @@ -1,6 +1,6 @@ /* * IDENTIFICATION: - * stub generated Mon Aug 27 17:58:23 2007 + * stub generated Thu Oct 11 16:40:18 2007 * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com * OPTIONS: */ diff --git a/macosx/RPC/JackRPCEngine.defs b/macosx/RPC/JackRPCEngine.defs index 1b1aead2..5d7ff7a3 100644 --- a/macosx/RPC/JackRPCEngine.defs +++ b/macosx/RPC/JackRPCEngine.defs @@ -27,6 +27,8 @@ ServerPrefix server_; type client_name_t = c_string[128]; type client_port_name_t = c_string[128]; +type so_name_t = c_string[1024]; +type objet_data_t = c_string[1024]; routine rpc_jack_client_open( server_port : mach_port_t; @@ -124,6 +126,39 @@ routine rpc_jack_set_timebase_callback( 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; diff --git a/macosx/RPC/JackRPCEngine.h b/macosx/RPC/JackRPCEngine.h index ca9763e8..80757534 100644 --- a/macosx/RPC/JackRPCEngine.h +++ b/macosx/RPC/JackRPCEngine.h @@ -26,7 +26,7 @@ typedef function_table_entry *function_table_t; #endif /* AUTOTEST */ #ifndef JackRPCEngine_MSG_COUNT -#define JackRPCEngine_MSG_COUNT 16 +#define JackRPCEngine_MSG_COUNT 20 #endif /* JackRPCEngine_MSG_COUNT */ #include @@ -260,6 +260,71 @@ kern_return_t rpc_jack_set_timebase_callback int *result ); +/* Routine rpc_jack_get_internal_clientname */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t rpc_jack_get_internal_clientname +( + mach_port_t server_port, + int refnum, + int int_ref, + client_name_t client_name_res, + int *result +); + +/* Routine rpc_jack_internal_clienthandle */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t rpc_jack_internal_clienthandle +( + mach_port_t server_port, + int refnum, + client_name_t client_name, + int *int_ref, + int *status, + int *result +); + +/* Routine rpc_jack_internal_clientload */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t rpc_jack_internal_clientload +( + mach_port_t server_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 +); + +/* Routine rpc_jack_internal_clientunload */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t rpc_jack_internal_clientunload +( + mach_port_t server_port, + int refnum, + int int_ref, + int *status, + int *result +); + /* SimpleRoutine rpc_jack_client_rt_notify */ #ifdef mig_external mig_external @@ -488,6 +553,61 @@ __END_DECLS #pragma pack() #endif +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + } __Request__rpc_jack_get_internal_clientname_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; + } __Request__rpc_jack_internal_clienthandle_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; + so_name_t so_name; + objet_data_t objet_data; + int options; + } __Request__rpc_jack_internal_clientload_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; + int int_ref; + } __Request__rpc_jack_internal_clientunload_t; +#ifdef __MigPackStructs +#pragma pack() +#endif + #ifdef __MigPackStructs #pragma pack(4) #endif @@ -523,6 +643,10 @@ union __RequestUnion__JackRPCEngine_subsystem { __Request__rpc_jack_set_freewheel_t Request_rpc_jack_set_freewheel; __Request__rpc_jack_release_timebase_t Request_rpc_jack_release_timebase; __Request__rpc_jack_set_timebase_callback_t Request_rpc_jack_set_timebase_callback; + __Request__rpc_jack_get_internal_clientname_t Request_rpc_jack_get_internal_clientname; + __Request__rpc_jack_internal_clienthandle_t Request_rpc_jack_internal_clienthandle; + __Request__rpc_jack_internal_clientload_t Request_rpc_jack_internal_clientload; + __Request__rpc_jack_internal_clientunload_t Request_rpc_jack_internal_clientunload; __Request__rpc_jack_client_rt_notify_t Request_rpc_jack_client_rt_notify; }; #endif /* !__RequestUnion__JackRPCEngine_subsystem__defined */ @@ -735,6 +859,64 @@ union __RequestUnion__JackRPCEngine_subsystem { #pragma pack() #endif +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + kern_return_t RetCode; + client_name_t client_name_res; + int result; + } __Reply__rpc_jack_get_internal_clientname_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; + int int_ref; + int status; + int result; + } __Reply__rpc_jack_internal_clienthandle_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; + int status; + int int_ref; + int result; + } __Reply__rpc_jack_internal_clientload_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; + int status; + int result; + } __Reply__rpc_jack_internal_clientunload_t; +#ifdef __MigPackStructs +#pragma pack() +#endif + #ifdef __MigPackStructs #pragma pack(4) #endif @@ -768,6 +950,10 @@ union __ReplyUnion__JackRPCEngine_subsystem { __Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel; __Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase; __Reply__rpc_jack_set_timebase_callback_t Reply_rpc_jack_set_timebase_callback; + __Reply__rpc_jack_get_internal_clientname_t Reply_rpc_jack_get_internal_clientname; + __Reply__rpc_jack_internal_clienthandle_t Reply_rpc_jack_internal_clienthandle; + __Reply__rpc_jack_internal_clientload_t Reply_rpc_jack_internal_clientload; + __Reply__rpc_jack_internal_clientunload_t Reply_rpc_jack_internal_clientunload; __Reply__rpc_jack_client_rt_notify_t Reply_rpc_jack_client_rt_notify; }; #endif /* !__RequestUnion__JackRPCEngine_subsystem__defined */ @@ -789,7 +975,11 @@ union __ReplyUnion__JackRPCEngine_subsystem { { "rpc_jack_set_freewheel", 1012 },\ { "rpc_jack_release_timebase", 1013 },\ { "rpc_jack_set_timebase_callback", 1014 },\ - { "rpc_jack_client_rt_notify", 1015 } + { "rpc_jack_get_internal_clientname", 1015 },\ + { "rpc_jack_internal_clienthandle", 1016 },\ + { "rpc_jack_internal_clientload", 1017 },\ + { "rpc_jack_internal_clientunload", 1018 },\ + { "rpc_jack_client_rt_notify", 1019 } #endif #ifdef __AfterMigUserHeader diff --git a/macosx/RPC/JackRPCEngineServer.c b/macosx/RPC/JackRPCEngineServer.c index 04d65aa5..4f9f3f9e 100644 --- a/macosx/RPC/JackRPCEngineServer.c +++ b/macosx/RPC/JackRPCEngineServer.c @@ -1,6 +1,6 @@ /* * IDENTIFICATION: - * stub generated Mon Aug 27 17:58:23 2007 + * stub generated Thu Oct 11 16:40:18 2007 * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com * OPTIONS: */ @@ -299,6 +299,61 @@ #pragma pack() #endif +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + } __Request__rpc_jack_get_internal_clientname_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; + } __Request__rpc_jack_internal_clienthandle_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; + so_name_t so_name; + objet_data_t objet_data; + int options; + } __Request__rpc_jack_internal_clientload_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; + int int_ref; + } __Request__rpc_jack_internal_clientunload_t; +#ifdef __MigPackStructs +#pragma pack() +#endif + #ifdef __MigPackStructs #pragma pack(4) #endif @@ -523,6 +578,64 @@ #pragma pack() #endif +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + kern_return_t RetCode; + client_name_t client_name_res; + int result; + } __Reply__rpc_jack_get_internal_clientname_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; + int int_ref; + int status; + int result; + } __Reply__rpc_jack_internal_clienthandle_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; + int status; + int int_ref; + int result; + } __Reply__rpc_jack_internal_clientload_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; + int status; + int result; + } __Reply__rpc_jack_internal_clientunload_t; +#ifdef __MigPackStructs +#pragma pack() +#endif + #ifdef __MigPackStructs #pragma pack(4) #endif @@ -557,6 +670,10 @@ union __ReplyUnion__server_JackRPCEngine_subsystem { __Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel; __Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase; __Reply__rpc_jack_set_timebase_callback_t Reply_rpc_jack_set_timebase_callback; + __Reply__rpc_jack_get_internal_clientname_t Reply_rpc_jack_get_internal_clientname; + __Reply__rpc_jack_internal_clienthandle_t Reply_rpc_jack_internal_clienthandle; + __Reply__rpc_jack_internal_clientload_t Reply_rpc_jack_internal_clientload; + __Reply__rpc_jack_internal_clientunload_t Reply_rpc_jack_internal_clientunload; __Reply__rpc_jack_client_rt_notify_t Reply_rpc_jack_client_rt_notify; }; #endif /* __RequestUnion__server_JackRPCEngine_subsystem__defined */ @@ -608,6 +725,18 @@ mig_internal novalue _Xrpc_jack_release_timebase mig_internal novalue _Xrpc_jack_set_timebase_callback (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); +mig_internal novalue _Xrpc_jack_get_internal_clientname + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); + +mig_internal novalue _Xrpc_jack_internal_clienthandle + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); + +mig_internal novalue _Xrpc_jack_internal_clientload + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); + +mig_internal novalue _Xrpc_jack_internal_clientunload + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); + mig_internal novalue _Xrpc_jack_client_rt_notify (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP); @@ -4362,232 +4491,1452 @@ mig_internal novalue _Xrpc_jack_set_timebase_callback #if (__MigTypeCheck || __NDR_convert__ ) #if __MIG_check__Request__JackRPCEngine_subsystem__ -#if !defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) -#define __MIG_check__Request__rpc_jack_client_rt_notify_t__defined -#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) -#elif defined(__NDR_convert__int_rep__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__int_rep__int((int *)(a), f) -#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) -#elif defined(__NDR_convert__int_rep__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__int_rep__int32_t((int32_t *)(a), f) -#endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ - -#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#if !defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) +#define __MIG_check__Request__rpc_jack_get_internal_clientname_t__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__int_rep__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__int_rep__int((int *)(a), f) #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__int_rep__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__int_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ -#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined #if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__int_rep__int__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__int_rep__int((int *)(a), f) #elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__int_rep__int32_t__defined) -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__int_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ - -#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) -#elif defined(__NDR_convert__char_rep__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__char_rep__int((int *)(a), f) -#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) -#elif defined(__NDR_convert__char_rep__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__char_rep__int32_t((int32_t *)(a), f) -#endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ -#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#ifndef __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__char_rep__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__char_rep__int((int *)(a), f) #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__char_rep__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__char_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ -#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#ifndef __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined #if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__char_rep__int__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__char_rep__int((int *)(a), f) #elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__char_rep__int32_t__defined) -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__char_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ - -#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) -#elif defined(__NDR_convert__float_rep__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__float_rep__int((int *)(a), f) -#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) -#elif defined(__NDR_convert__float_rep__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ - __NDR_convert__float_rep__int32_t((int32_t *)(a), f) -#endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ -#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#ifndef __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__float_rep__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__float_rep__int((int *)(a), f) #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__float_rep__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(a, f) \ __NDR_convert__float_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ -#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#ifndef __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined #if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) #elif defined(__NDR_convert__float_rep__int__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__float_rep__int((int *)(a), f) #elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) #elif defined(__NDR_convert__float_rep__int32_t__defined) -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined -#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(a, f) \ __NDR_convert__float_rep__int32_t((int32_t *)(a), f) #endif /* defined(__NDR_convert__*__defined) */ -#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ -mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_rt_notify_t(__Request__rpc_jack_client_rt_notify_t *In0P) +mig_internal kern_return_t __MIG_check__Request__rpc_jack_get_internal_clientname_t(__Request__rpc_jack_get_internal_clientname_t *In0P) { - typedef __Request__rpc_jack_client_rt_notify_t __Request; + typedef __Request__rpc_jack_get_internal_clientname_t __Request; #if __MigTypeCheck if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) || (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))) return MIG_BAD_ARGUMENTS; #endif /* __MigTypeCheck */ -#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ - defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \ - defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined) +#if defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) if (In0P->NDR.int_rep != NDR_record.int_rep) { -#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) - __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.int_rep); -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ -#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) - __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.int_rep); -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ -#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined) - __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.int_rep); -#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) + __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) + __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ } #endif /* defined(__NDR_convert__int_rep...) */ -#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ - defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \ - defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined) +#if defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) if (In0P->NDR.char_rep != NDR_record.char_rep) { -#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) - __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.char_rep); -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ -#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) - __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.char_rep); -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ -#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined) - __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.char_rep); -#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) + __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) + __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ } #endif /* defined(__NDR_convert__char_rep...) */ -#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) + if (In0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined) + __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum(&In0P->refnum, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__refnum__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined) + __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref(&In0P->int_ref, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_get_internal_clientname_t__int_ref__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) */ +#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_get_internal_clientname */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t server_rpc_jack_get_internal_clientname +( + mach_port_t server_port, + int refnum, + int int_ref, + client_name_t client_name_res, + int *result +); + +/* Routine rpc_jack_get_internal_clientname */ +mig_internal novalue _Xrpc_jack_get_internal_clientname + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP) +{ + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + mach_msg_trailer_t trailer; + } Request; +#ifdef __MigPackStructs +#pragma pack() +#endif + typedef __Request__rpc_jack_get_internal_clientname_t __Request; + typedef __Reply__rpc_jack_get_internal_clientname_t Reply; + + /* + * typedef struct { + * mach_msg_header_t Head; + * NDR_record_t NDR; + * kern_return_t RetCode; + * } mig_reply_error_t; + */ + + Request *In0P = (Request *) InHeadP; + Reply *OutP = (Reply *) OutHeadP; +#ifdef __MIG_check__Request__rpc_jack_get_internal_clientname_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Request__rpc_jack_get_internal_clientname_t__defined */ + + __DeclareRcvRpc(1015, "rpc_jack_get_internal_clientname") + __BeforeRcvRpc(1015, "rpc_jack_get_internal_clientname") + +#if defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) + check_result = __MIG_check__Request__rpc_jack_get_internal_clientname_t((__Request *)In0P); + if (check_result != MACH_MSG_SUCCESS) + { MIG_RETURN_ERROR(OutP, check_result); } +#endif /* defined(__MIG_check__Request__rpc_jack_get_internal_clientname_t__defined) */ + + OutP->RetCode = server_rpc_jack_get_internal_clientname(In0P->Head.msgh_request_port, In0P->refnum, In0P->int_ref, OutP->client_name_res, &OutP->result); + if (OutP->RetCode != KERN_SUCCESS) { + MIG_RETURN_ERROR(OutP, OutP->RetCode); + } + + OutP->NDR = NDR_record; + + + OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply)); + __AfterRcvRpc(1015, "rpc_jack_get_internal_clientname") +} + +#if (__MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Request__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) +#define __MIG_check__Request__rpc_jack_internal_clienthandle_t__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__client_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__int_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__int_rep__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__int_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__client_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__char_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__char_rep__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__char_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__client_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__float_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__float_rep__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(a, f) \ + __NDR_convert__float_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + + +mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clienthandle_t(__Request__rpc_jack_internal_clienthandle_t *In0P) +{ + + typedef __Request__rpc_jack_internal_clienthandle_t __Request; +#if __MigTypeCheck + if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) || + (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))) + return MIG_BAD_ARGUMENTS; +#endif /* __MigTypeCheck */ + +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + if (In0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + if (In0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + if (In0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum(&In0P->refnum, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__refnum__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name(&In0P->client_name, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clienthandle_t__client_name__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) */ +#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clienthandle */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t server_rpc_jack_internal_clienthandle +( + mach_port_t server_port, + int refnum, + client_name_t client_name, + int *int_ref, + int *status, + int *result +); + +/* Routine rpc_jack_internal_clienthandle */ +mig_internal novalue _Xrpc_jack_internal_clienthandle + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP) +{ + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + client_name_t client_name; + mach_msg_trailer_t trailer; + } Request; +#ifdef __MigPackStructs +#pragma pack() +#endif + typedef __Request__rpc_jack_internal_clienthandle_t __Request; + typedef __Reply__rpc_jack_internal_clienthandle_t Reply; + + /* + * typedef struct { + * mach_msg_header_t Head; + * NDR_record_t NDR; + * kern_return_t RetCode; + * } mig_reply_error_t; + */ + + Request *In0P = (Request *) InHeadP; + Reply *OutP = (Reply *) OutHeadP; +#ifdef __MIG_check__Request__rpc_jack_internal_clienthandle_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Request__rpc_jack_internal_clienthandle_t__defined */ + + __DeclareRcvRpc(1016, "rpc_jack_internal_clienthandle") + __BeforeRcvRpc(1016, "rpc_jack_internal_clienthandle") + +#if defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) + check_result = __MIG_check__Request__rpc_jack_internal_clienthandle_t((__Request *)In0P); + if (check_result != MACH_MSG_SUCCESS) + { MIG_RETURN_ERROR(OutP, check_result); } +#endif /* defined(__MIG_check__Request__rpc_jack_internal_clienthandle_t__defined) */ + + OutP->RetCode = server_rpc_jack_internal_clienthandle(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, &OutP->int_ref, &OutP->status, &OutP->result); + if (OutP->RetCode != KERN_SUCCESS) { + MIG_RETURN_ERROR(OutP, OutP->RetCode); + } + + OutP->NDR = NDR_record; + + + OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply)); + __AfterRcvRpc(1016, "rpc_jack_internal_clienthandle") +} + +#if (__MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Request__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) +#define __MIG_check__Request__rpc_jack_internal_clientload_t__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__client_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__int_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__int_rep__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__int_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__so_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__so_name_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__int_rep__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__int_rep__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__int_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__objet_data_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__int_rep__objet_data_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__int_rep__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__int_rep__string__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__int_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__client_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__char_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__char_rep__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__char_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__so_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__so_name_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__char_rep__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__char_rep__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__char_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__objet_data_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__char_rep__objet_data_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__char_rep__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__char_rep__string__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__char_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__client_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__float_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__float_rep__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(a, f) \ + __NDR_convert__float_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__so_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__so_name_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__float_rep__so_name_t((so_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__float_rep__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(a, f) \ + __NDR_convert__float_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__objet_data_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__float_rep__objet_data_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__float_rep__objet_data_t((objet_data_t *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__string(a, f, 1024) +#elif defined(__NDR_convert__float_rep__string__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(a, f) \ + __NDR_convert__float_rep__string(a, f, 1024) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + + +mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clientload_t(__Request__rpc_jack_internal_clientload_t *In0P) +{ + + typedef __Request__rpc_jack_internal_clientload_t __Request; +#if __MigTypeCheck + if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) || + (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))) + return MIG_BAD_ARGUMENTS; +#endif /* __MigTypeCheck */ + +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined) + if (In0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined) + if (In0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined) + if (In0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum(&In0P->refnum, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__refnum__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name(&In0P->client_name, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__client_name__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name(&In0P->so_name, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__so_name__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data(&In0P->objet_data, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__objet_data__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options(&In0P->options, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientload_t__options__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) */ +#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clientload */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t server_rpc_jack_internal_clientload +( + mach_port_t server_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 +); + +/* Routine rpc_jack_internal_clientload */ +mig_internal novalue _Xrpc_jack_internal_clientload + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP) +{ + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + client_name_t client_name; + so_name_t so_name; + objet_data_t objet_data; + int options; + mach_msg_trailer_t trailer; + } Request; +#ifdef __MigPackStructs +#pragma pack() +#endif + typedef __Request__rpc_jack_internal_clientload_t __Request; + typedef __Reply__rpc_jack_internal_clientload_t Reply; + + /* + * typedef struct { + * mach_msg_header_t Head; + * NDR_record_t NDR; + * kern_return_t RetCode; + * } mig_reply_error_t; + */ + + Request *In0P = (Request *) InHeadP; + Reply *OutP = (Reply *) OutHeadP; +#ifdef __MIG_check__Request__rpc_jack_internal_clientload_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Request__rpc_jack_internal_clientload_t__defined */ + + __DeclareRcvRpc(1017, "rpc_jack_internal_clientload") + __BeforeRcvRpc(1017, "rpc_jack_internal_clientload") + +#if defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) + check_result = __MIG_check__Request__rpc_jack_internal_clientload_t((__Request *)In0P); + if (check_result != MACH_MSG_SUCCESS) + { MIG_RETURN_ERROR(OutP, check_result); } +#endif /* defined(__MIG_check__Request__rpc_jack_internal_clientload_t__defined) */ + + OutP->RetCode = server_rpc_jack_internal_clientload(In0P->Head.msgh_request_port, In0P->refnum, In0P->client_name, In0P->so_name, In0P->objet_data, In0P->options, &OutP->status, &OutP->int_ref, &OutP->result); + if (OutP->RetCode != KERN_SUCCESS) { + MIG_RETURN_ERROR(OutP, OutP->RetCode); + } + + OutP->NDR = NDR_record; + + + OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply)); + __AfterRcvRpc(1017, "rpc_jack_internal_clientload") +} + +#if (__MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Request__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) +#define __MIG_check__Request__rpc_jack_internal_clientunload_t__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined +#define __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + + +mig_internal kern_return_t __MIG_check__Request__rpc_jack_internal_clientunload_t(__Request__rpc_jack_internal_clientunload_t *In0P) +{ + + typedef __Request__rpc_jack_internal_clientunload_t __Request; +#if __MigTypeCheck + if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) || + (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))) + return MIG_BAD_ARGUMENTS; +#endif /* __MigTypeCheck */ + +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + if (In0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + if (In0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) || \ + defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + if (In0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum(&In0P->refnum, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__refnum__defined */ +#if defined(__NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined) + __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref(&In0P->int_ref, In0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Request__rpc_jack_internal_clientunload_t__int_ref__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) */ +#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clientunload */ +#ifdef mig_external +mig_external +#else +extern +#endif /* mig_external */ +kern_return_t server_rpc_jack_internal_clientunload +( + mach_port_t server_port, + int refnum, + int int_ref, + int *status, + int *result +); + +/* Routine rpc_jack_internal_clientunload */ +mig_internal novalue _Xrpc_jack_internal_clientunload + (mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP) +{ + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + mach_msg_trailer_t trailer; + } Request; +#ifdef __MigPackStructs +#pragma pack() +#endif + typedef __Request__rpc_jack_internal_clientunload_t __Request; + typedef __Reply__rpc_jack_internal_clientunload_t Reply; + + /* + * typedef struct { + * mach_msg_header_t Head; + * NDR_record_t NDR; + * kern_return_t RetCode; + * } mig_reply_error_t; + */ + + Request *In0P = (Request *) InHeadP; + Reply *OutP = (Reply *) OutHeadP; +#ifdef __MIG_check__Request__rpc_jack_internal_clientunload_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Request__rpc_jack_internal_clientunload_t__defined */ + + __DeclareRcvRpc(1018, "rpc_jack_internal_clientunload") + __BeforeRcvRpc(1018, "rpc_jack_internal_clientunload") + +#if defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) + check_result = __MIG_check__Request__rpc_jack_internal_clientunload_t((__Request *)In0P); + if (check_result != MACH_MSG_SUCCESS) + { MIG_RETURN_ERROR(OutP, check_result); } +#endif /* defined(__MIG_check__Request__rpc_jack_internal_clientunload_t__defined) */ + + OutP->RetCode = server_rpc_jack_internal_clientunload(In0P->Head.msgh_request_port, In0P->refnum, In0P->int_ref, &OutP->status, &OutP->result); + if (OutP->RetCode != KERN_SUCCESS) { + MIG_RETURN_ERROR(OutP, OutP->RetCode); + } + + OutP->NDR = NDR_record; + + + OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply)); + __AfterRcvRpc(1018, "rpc_jack_internal_clientunload") +} + +#if (__MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Request__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) +#define __MIG_check__Request__rpc_jack_client_rt_notify_t__defined +#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ + +#ifndef __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__int_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ + +#ifndef __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__char_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ + +#ifndef __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined +#define __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value(a, f) \ + __NDR_convert__float_rep__int32_t((int32_t *)(a), f) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ + + +mig_internal kern_return_t __MIG_check__Request__rpc_jack_client_rt_notify_t(__Request__rpc_jack_client_rt_notify_t *In0P) +{ + + typedef __Request__rpc_jack_client_rt_notify_t __Request; +#if __MigTypeCheck + if ((In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) || + (In0P->Head.msgh_size != (mach_msg_size_t)sizeof(__Request))) + return MIG_BAD_ARGUMENTS; +#endif /* __MigTypeCheck */ + +#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \ + defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined) + if (In0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) + __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) + __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ +#if defined(__NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined) + __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \ + defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined) + if (In0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) + __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum(&In0P->refnum, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) + __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify(&In0P->notify, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__notify__defined */ +#if defined(__NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined) + __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value(&In0P->value, In0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Request__rpc_jack_client_rt_notify_t__value__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__refnum__defined) || \ defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__notify__defined) || \ defined(__NDR_convert__float_rep__Request__rpc_jack_client_rt_notify_t__value__defined) if (In0P->NDR.float_rep != NDR_record.float_rep) { @@ -4660,8 +6009,8 @@ mig_internal novalue _Xrpc_jack_client_rt_notify kern_return_t check_result; #endif /* __MIG_check__Request__rpc_jack_client_rt_notify_t__defined */ - __DeclareRcvSimple(1015, "rpc_jack_client_rt_notify") - __BeforeRcvSimple(1015, "rpc_jack_client_rt_notify") + __DeclareRcvSimple(1019, "rpc_jack_client_rt_notify") + __BeforeRcvSimple(1019, "rpc_jack_client_rt_notify") #if defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) check_result = __MIG_check__Request__rpc_jack_client_rt_notify_t((__Request *)In0P); @@ -4670,7 +6019,7 @@ mig_internal novalue _Xrpc_jack_client_rt_notify #endif /* defined(__MIG_check__Request__rpc_jack_client_rt_notify_t__defined) */ OutP->RetCode = server_rpc_jack_client_rt_notify(In0P->Head.msgh_request_port, In0P->refnum, In0P->notify, In0P->value); - __AfterRcvSimple(1015, "rpc_jack_client_rt_notify") + __AfterRcvSimple(1019, "rpc_jack_client_rt_notify") } @@ -4690,11 +6039,11 @@ const struct server_JackRPCEngine_subsystem { unsigned int maxsize; /* Max msg size */ vm_address_t reserved; /* Reserved */ struct routine_descriptor /*Array of routine descriptors */ - routine[16]; + routine[20]; } server_JackRPCEngine_subsystem = { JackRPCEngine_server_routine, 1000, - 1016, + 1020, (mach_msg_size_t)sizeof(union __ReplyUnion__server_JackRPCEngine_subsystem), (vm_address_t)0, { @@ -4728,6 +6077,14 @@ const struct server_JackRPCEngine_subsystem { (mig_stub_routine_t) _Xrpc_jack_release_timebase, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_release_timebase_t)}, { (mig_impl_routine_t) 0, (mig_stub_routine_t) _Xrpc_jack_set_timebase_callback, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_set_timebase_callback_t)}, + { (mig_impl_routine_t) 0, + (mig_stub_routine_t) _Xrpc_jack_get_internal_clientname, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_get_internal_clientname_t)}, + { (mig_impl_routine_t) 0, + (mig_stub_routine_t) _Xrpc_jack_internal_clienthandle, 6, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clienthandle_t)}, + { (mig_impl_routine_t) 0, + (mig_stub_routine_t) _Xrpc_jack_internal_clientload, 9, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clientload_t)}, + { (mig_impl_routine_t) 0, + (mig_stub_routine_t) _Xrpc_jack_internal_clientunload, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_internal_clientunload_t)}, { (mig_impl_routine_t) 0, (mig_stub_routine_t) _Xrpc_jack_client_rt_notify, 4, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_client_rt_notify_t)}, } @@ -4753,7 +6110,7 @@ mig_external boolean_t JackRPCEngine_server OutHeadP->msgh_local_port = MACH_PORT_NULL; OutHeadP->msgh_id = InHeadP->msgh_id + 100; - if ((InHeadP->msgh_id > 1015) || (InHeadP->msgh_id < 1000) || + if ((InHeadP->msgh_id > 1019) || (InHeadP->msgh_id < 1000) || ((routine = server_JackRPCEngine_subsystem.routine[InHeadP->msgh_id - 1000].stub_routine) == 0)) { ((mig_reply_error_t *)OutHeadP)->NDR = NDR_record; ((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID; @@ -4770,7 +6127,7 @@ mig_external mig_routine_t JackRPCEngine_server_routine msgh_id = InHeadP->msgh_id - 1000; - if ((msgh_id > 15) || (msgh_id < 0)) + if ((msgh_id > 19) || (msgh_id < 0)) return 0; return server_JackRPCEngine_subsystem.routine[msgh_id].stub_routine; diff --git a/macosx/RPC/JackRPCEngineUser.c b/macosx/RPC/JackRPCEngineUser.c index 8f296c79..882ce287 100644 --- a/macosx/RPC/JackRPCEngineUser.c +++ b/macosx/RPC/JackRPCEngineUser.c @@ -1,6 +1,6 @@ /* * IDENTIFICATION: - * stub generated Mon Aug 27 17:58:23 2007 + * stub generated Thu Oct 11 16:40:18 2007 * with a MiG generated Mon Sep 11 19:11:05 PDT 2006 by root@b09.apple.com * OPTIONS: */ @@ -4467,6 +4467,1534 @@ mig_external kern_return_t rpc_jack_set_timebase_callback } } +#if ( __MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Reply__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) +#define __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__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_get_internal_clientname_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_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_get_internal_clientname_t__RetCode__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__client_name_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__int_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__string__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__int_rep__string__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__int_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_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_get_internal_clientname_t__result__defined */ + + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__client_name_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__char_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__string__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__char_rep__string__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__char_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_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_get_internal_clientname_t__result__defined */ + + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__client_name_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__client_name_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__float_rep__client_name_t((client_name_t *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__string__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__string(a, f, 128) +#elif defined(__NDR_convert__float_rep__string__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(a, f) \ + __NDR_convert__float_rep__string(a, f, 128) +#endif /* defined(__NDR_convert__*__defined) */ +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_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_get_internal_clientname_t__result__defined */ + + + +mig_internal kern_return_t __MIG_check__Reply__rpc_jack_get_internal_clientname_t(__Reply__rpc_jack_get_internal_clientname_t *Out0P) +{ + + typedef __Reply__rpc_jack_get_internal_clientname_t __Reply; +#if __MigTypeCheck + unsigned int msgh_size; +#endif /* __MigTypeCheck */ + if (Out0P->Head.msgh_id != 1115) { + 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_get_internal_clientname_t__RetCode__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + if (Out0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined) + __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__RetCode__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) + __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if 0 || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + if (Out0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) + __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if 0 || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + if (Out0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined) + __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res(&Out0P->client_name_res, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__client_name_res__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined) + __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result(&Out0P->result, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_get_internal_clientname_t__result__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */ +#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_get_internal_clientname */ +mig_external kern_return_t rpc_jack_get_internal_clientname +( + mach_port_t server_port, + int refnum, + int int_ref, + client_name_t client_name_res, + int *result +) +{ + { + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + } 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; + client_name_t client_name_res; + 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; + client_name_t client_name_res; + 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_get_internal_clientname_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined */ + + __DeclareSendRpc(1015, "rpc_jack_get_internal_clientname") + + InP->NDR = NDR_record; + + InP->refnum = refnum; + + InP->int_ref = int_ref; + + InP->Head.msgh_bits = + MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE); + /* msgh_size passed as argument */ + InP->Head.msgh_request_port = server_port; + InP->Head.msgh_reply_port = mig_get_reply_port(); + InP->Head.msgh_id = 1015; + + __BeforeSendRpc(1015, "rpc_jack_get_internal_clientname") + msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + __AfterSendRpc(1015, "rpc_jack_get_internal_clientname") + if (msg_result != MACH_MSG_SUCCESS) { + __MachMsgErrorWithoutTimeout(msg_result); + { return msg_result; } + } + + +#if defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) + check_result = __MIG_check__Reply__rpc_jack_get_internal_clientname_t((__Reply__rpc_jack_get_internal_clientname_t *)Out0P); + if (check_result != MACH_MSG_SUCCESS) + { return check_result; } +#endif /* defined(__MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined) */ + + (void) mig_strncpy(client_name_res, Out0P->client_name_res, 128); + + *result = Out0P->result; + + return KERN_SUCCESS; + } +} + +#if ( __MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Reply__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) +#define __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__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_internal_clienthandle_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_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_internal_clienthandle_t__RetCode__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(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_internal_clienthandle_t__int_ref__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(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_internal_clienthandle_t__status__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_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_internal_clienthandle_t__result__defined */ + + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(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_internal_clienthandle_t__int_ref__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(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_internal_clienthandle_t__status__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_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_internal_clienthandle_t__result__defined */ + + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(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_internal_clienthandle_t__int_ref__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(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_internal_clienthandle_t__status__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_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_internal_clienthandle_t__result__defined */ + + + +mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clienthandle_t(__Reply__rpc_jack_internal_clienthandle_t *Out0P) +{ + + typedef __Reply__rpc_jack_internal_clienthandle_t __Reply; +#if __MigTypeCheck + unsigned int msgh_size; +#endif /* __MigTypeCheck */ + if (Out0P->Head.msgh_id != 1116) { + 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_internal_clienthandle_t__RetCode__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + if (Out0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__RetCode__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if 0 || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + if (Out0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if 0 || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + if (Out0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__int_ref__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status(&Out0P->status, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__status__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result(&Out0P->result, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clienthandle_t__result__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */ +#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clienthandle */ +mig_external kern_return_t rpc_jack_internal_clienthandle +( + mach_port_t server_port, + int refnum, + client_name_t client_name, + int *int_ref, + int *status, + 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; + } 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 int_ref; + int status; + 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 int_ref; + int status; + 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_internal_clienthandle_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined */ + + __DeclareSendRpc(1016, "rpc_jack_internal_clienthandle") + + InP->NDR = NDR_record; + + InP->refnum = refnum; + + (void) mig_strncpy(InP->client_name, client_name, 128); + + InP->Head.msgh_bits = + MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE); + /* msgh_size passed as argument */ + InP->Head.msgh_request_port = server_port; + InP->Head.msgh_reply_port = mig_get_reply_port(); + InP->Head.msgh_id = 1016; + + __BeforeSendRpc(1016, "rpc_jack_internal_clienthandle") + msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + __AfterSendRpc(1016, "rpc_jack_internal_clienthandle") + if (msg_result != MACH_MSG_SUCCESS) { + __MachMsgErrorWithoutTimeout(msg_result); + { return msg_result; } + } + + +#if defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) + check_result = __MIG_check__Reply__rpc_jack_internal_clienthandle_t((__Reply__rpc_jack_internal_clienthandle_t *)Out0P); + if (check_result != MACH_MSG_SUCCESS) + { return check_result; } +#endif /* defined(__MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined) */ + + *int_ref = Out0P->int_ref; + + *status = Out0P->status; + + *result = Out0P->result; + + return KERN_SUCCESS; + } +} + +#if ( __MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Reply__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) +#define __MIG_check__Reply__rpc_jack_internal_clientload_t__defined +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__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_internal_clientload_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_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_internal_clientload_t__RetCode__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(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_internal_clientload_t__status__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(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_internal_clientload_t__int_ref__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_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_internal_clientload_t__result__defined */ + + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(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_internal_clientload_t__status__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(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_internal_clientload_t__int_ref__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_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_internal_clientload_t__result__defined */ + + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(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_internal_clientload_t__status__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(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_internal_clientload_t__int_ref__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_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_internal_clientload_t__result__defined */ + + + +mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientload_t(__Reply__rpc_jack_internal_clientload_t *Out0P) +{ + + typedef __Reply__rpc_jack_internal_clientload_t __Reply; +#if __MigTypeCheck + unsigned int msgh_size; +#endif /* __MigTypeCheck */ + if (Out0P->Head.msgh_id != 1117) { + 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_internal_clientload_t__RetCode__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + if (Out0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__RetCode__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__status__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientload_t__result__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if 0 || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + if (Out0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__status__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientload_t__result__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if 0 || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + if (Out0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status(&Out0P->status, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__status__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref(&Out0P->int_ref, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__int_ref__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result(&Out0P->result, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientload_t__result__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */ +#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clientload */ +mig_external kern_return_t rpc_jack_internal_clientload +( + mach_port_t server_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 +) +{ + { + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + client_name_t client_name; + so_name_t so_name; + objet_data_t objet_data; + int options; + } 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 status; + int int_ref; + 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 status; + int int_ref; + 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_internal_clientload_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Reply__rpc_jack_internal_clientload_t__defined */ + + __DeclareSendRpc(1017, "rpc_jack_internal_clientload") + + InP->NDR = NDR_record; + + InP->refnum = refnum; + + (void) mig_strncpy(InP->client_name, client_name, 128); + + (void) mig_strncpy(InP->so_name, so_name, 1024); + + (void) mig_strncpy(InP->objet_data, objet_data, 1024); + + InP->options = options; + + InP->Head.msgh_bits = + MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE); + /* msgh_size passed as argument */ + InP->Head.msgh_request_port = server_port; + InP->Head.msgh_reply_port = mig_get_reply_port(); + InP->Head.msgh_id = 1017; + + __BeforeSendRpc(1017, "rpc_jack_internal_clientload") + msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + __AfterSendRpc(1017, "rpc_jack_internal_clientload") + if (msg_result != MACH_MSG_SUCCESS) { + __MachMsgErrorWithoutTimeout(msg_result); + { return msg_result; } + } + + +#if defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) + check_result = __MIG_check__Reply__rpc_jack_internal_clientload_t((__Reply__rpc_jack_internal_clientload_t *)Out0P); + if (check_result != MACH_MSG_SUCCESS) + { return check_result; } +#endif /* defined(__MIG_check__Reply__rpc_jack_internal_clientload_t__defined) */ + + *status = Out0P->status; + + *int_ref = Out0P->int_ref; + + *result = Out0P->result; + + return KERN_SUCCESS; + } +} + +#if ( __MigTypeCheck || __NDR_convert__ ) +#if __MIG_check__Reply__JackRPCEngine_subsystem__ +#if !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) +#define __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__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_internal_clientunload_t__RetCode__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_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_internal_clientunload_t__RetCode__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(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_internal_clientunload_t__status__defined */ + + +#ifndef __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#if defined(__NDR_convert__int_rep__JackRPCEngine__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__int__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__int_rep__int((int *)(a), f) +#elif defined(__NDR_convert__int_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__int_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__int_rep__int32_t__defined) +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_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_internal_clientunload_t__result__defined */ + + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(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_internal_clientunload_t__status__defined */ + + +#ifndef __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#if defined(__NDR_convert__char_rep__JackRPCEngine__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__int__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__char_rep__int((int *)(a), f) +#elif defined(__NDR_convert__char_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__char_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__char_rep__int32_t__defined) +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_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_internal_clientunload_t__result__defined */ + + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(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_internal_clientunload_t__status__defined */ + + +#ifndef __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#if defined(__NDR_convert__float_rep__JackRPCEngine__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__int__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__float_rep__int((int *)(a), f) +#elif defined(__NDR_convert__float_rep__JackRPCEngine__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(a, f) \ + __NDR_convert__float_rep__JackRPCEngine__int32_t((int32_t *)(a), f) +#elif defined(__NDR_convert__float_rep__int32_t__defined) +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined +#define __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_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_internal_clientunload_t__result__defined */ + + + +mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientunload_t(__Reply__rpc_jack_internal_clientunload_t *Out0P) +{ + + typedef __Reply__rpc_jack_internal_clientunload_t __Reply; +#if __MigTypeCheck + unsigned int msgh_size; +#endif /* __MigTypeCheck */ + if (Out0P->Head.msgh_id != 1118) { + 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_internal_clientunload_t__RetCode__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \ + defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + if (Out0P->NDR.int_rep != NDR_record.int_rep) { +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__RetCode__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */ +#if defined(__NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.int_rep); +#endif /* __NDR_convert__int_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */ + } +#endif /* defined(__NDR_convert__int_rep...) */ + +#if 0 || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \ + defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + if (Out0P->NDR.char_rep != NDR_record.char_rep) { +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */ +#if defined(__NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.char_rep); +#endif /* __NDR_convert__char_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */ + } +#endif /* defined(__NDR_convert__char_rep...) */ + +#if 0 || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) || \ + defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + if (Out0P->NDR.float_rep != NDR_record.float_rep) { +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status(&Out0P->status, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__status__defined */ +#if defined(__NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined) + __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result(&Out0P->result, Out0P->NDR.float_rep); +#endif /* __NDR_convert__float_rep__Reply__rpc_jack_internal_clientunload_t__result__defined */ + } +#endif /* defined(__NDR_convert__float_rep...) */ + + return MACH_MSG_SUCCESS; +} +#endif /* !defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */ +#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */ +#endif /* ( __MigTypeCheck || __NDR_convert__ ) */ + + +/* Routine rpc_jack_internal_clientunload */ +mig_external kern_return_t rpc_jack_internal_clientunload +( + mach_port_t server_port, + int refnum, + int int_ref, + int *status, + int *result +) +{ + { + +#ifdef __MigPackStructs +#pragma pack(4) +#endif + typedef struct { + mach_msg_header_t Head; + NDR_record_t NDR; + int refnum; + int int_ref; + } 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 status; + 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 status; + 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_internal_clientunload_t__defined + kern_return_t check_result; +#endif /* __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined */ + + __DeclareSendRpc(1018, "rpc_jack_internal_clientunload") + + InP->NDR = NDR_record; + + InP->refnum = refnum; + + InP->int_ref = int_ref; + + InP->Head.msgh_bits = + MACH_MSGH_BITS(19, MACH_MSG_TYPE_MAKE_SEND_ONCE); + /* msgh_size passed as argument */ + InP->Head.msgh_request_port = server_port; + InP->Head.msgh_reply_port = mig_get_reply_port(); + InP->Head.msgh_id = 1018; + + __BeforeSendRpc(1018, "rpc_jack_internal_clientunload") + msg_result = mach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|MACH_MSG_OPTION_NONE, (mach_msg_size_t)sizeof(Request), (mach_msg_size_t)sizeof(Reply), InP->Head.msgh_reply_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); + __AfterSendRpc(1018, "rpc_jack_internal_clientunload") + if (msg_result != MACH_MSG_SUCCESS) { + __MachMsgErrorWithoutTimeout(msg_result); + { return msg_result; } + } + + +#if defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) + check_result = __MIG_check__Reply__rpc_jack_internal_clientunload_t((__Reply__rpc_jack_internal_clientunload_t *)Out0P); + if (check_result != MACH_MSG_SUCCESS) + { return check_result; } +#endif /* defined(__MIG_check__Reply__rpc_jack_internal_clientunload_t__defined) */ + + *status = Out0P->status; + + *result = Out0P->result; + + return KERN_SUCCESS; + } +} + /* SimpleRoutine rpc_jack_client_rt_notify */ mig_external kern_return_t rpc_jack_client_rt_notify ( @@ -4512,7 +6040,7 @@ mig_external kern_return_t rpc_jack_client_rt_notify kern_return_t check_result; #endif /* __MIG_check__Reply__rpc_jack_client_rt_notify_t__defined */ - __DeclareSendSimple(1015, "rpc_jack_client_rt_notify") + __DeclareSendSimple(1019, "rpc_jack_client_rt_notify") InP->NDR = NDR_record; @@ -4527,11 +6055,11 @@ mig_external kern_return_t rpc_jack_client_rt_notify /* msgh_size passed as argument */ InP->Head.msgh_request_port = client_port; InP->Head.msgh_reply_port = MACH_PORT_NULL; - InP->Head.msgh_id = 1015; + InP->Head.msgh_id = 1019; - __BeforeSendSimple(1015, "rpc_jack_client_rt_notify") + __BeforeSendSimple(1019, "rpc_jack_client_rt_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, timeout, MACH_PORT_NULL); - __AfterSendSimple(1015, "rpc_jack_client_rt_notify") + __AfterSendSimple(1019, "rpc_jack_client_rt_notify") return msg_result; return KERN_SUCCESS; } diff --git a/macosx/RPC/Jackdefs.h b/macosx/RPC/Jackdefs.h index bfa035ce..ef8ff68c 100644 --- a/macosx/RPC/Jackdefs.h +++ b/macosx/RPC/Jackdefs.h @@ -1,4 +1,6 @@ -typedef char client_name_t[128]; -typedef char client_port_name_t[128]; \ No newline at end of file +typedef char client_name_t[64]; +typedef char client_port_name_t[256]; +typedef char so_name_t[256]; +typedef char objet_data_t[256]; \ No newline at end of file