Add new jack_set_port_rename_callback API, jack_port_set_name is now a server request that call port rename callbacks.

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@2857 0c269be4-1314-0410-8aa9-9f06e86f4224

ChangeLog

@@ -22,6 +22,10 @@ Florian Faber
   Jackdmp changes log
 ---------------------------
 
+2008-09-01 Stephane Letz  <letz@grame.fr>
+	
+	* Add new jack_set_port_rename_callback API, jack_port_set_name is now a server request that call port rename callbacks.
+
 2008-08-26 Stephane Letz  <letz@grame.fr>
 	
 	* Better parameter handling in JackCoreAudioAdapter.

common/JackAPI.cpp

@@ -113,6 +113,9 @@ extern "C"
     EXPORT int jack_set_port_connect_callback (jack_client_t *,
             JackPortConnectCallback
             connect_callback, void *arg);
+    EXPORT int jack_set_port_rename_callback (jack_client_t *,
+				    JackPortRenameCallback
+				    rename_callback, void *arg);
     EXPORT int jack_set_graph_order_callback (jack_client_t *,
             JackGraphOrderCallback graph_callback,
             void *);
@@ -552,7 +555,13 @@ EXPORT int jack_port_set_name(jack_port_t* port, const char* name)
         return -1;
     } else {
         JackGraphManager* manager = GetGraphManager();
-        return (manager ? manager->GetPort(myport)->SetName(name) : -1);
+        if (manager) {
+            JackClient* client = JackClient::fClientTable[manager->GetPort(myport)->GetRefNum()];
+            assert(client);
+            return client->PortRename(myport, name);
+        } else {
+            return -1;
+        }
     }
 }
 
@@ -886,6 +895,20 @@ EXPORT int jack_set_port_connect_callback(jack_client_t* ext_client, JackPortCon
     }
 }
 
+EXPORT int jack_set_port_rename_callback(jack_client_t* ext_client, JackPortRenameCallback rename_callback, void* arg)
+{
+#ifdef __CLIENTDEBUG__
+    JackLibGlobals::CheckContext();
+#endif
+    JackClient* client = (JackClient*)ext_client;
+    if (client == NULL) {
+        jack_error("jack_set_port_rename_callback called with a NULL client");
+        return -1;
+    } else {
+        return client->SetPortRenameCallback(rename_callback, arg);
+    }
+}
+
 EXPORT int jack_set_graph_order_callback(jack_client_t* ext_client, JackGraphOrderCallback graph_callback, void* arg)
 {
 #ifdef __CLIENTDEBUG__

common/JackChannel.h

@@ -100,6 +100,8 @@ class JackClientChannelInterface
         {}
         virtual void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
         {}
+        virtual void PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
+        {}
 
         virtual void SetBufferSize(jack_nframes_t buffer_size, int* result)
         {}

common/JackClient.cpp

@@ -41,6 +41,8 @@ using namespace std;
 namespace Jack
 {
 
+JackClient* JackClient::fClientTable[CLIENT_NUM] = {};
+
 #define IsRealTime() ((fProcess != NULL) | (fThreadFun != NULL) | (fSync != NULL) | (fTimebase != NULL))
 
 JackClient::JackClient():fThread(this)
@@ -59,6 +61,7 @@ JackClient::JackClient(JackSynchro* table):fThread(this)
     fFreewheel = NULL;
     fPortRegistration = NULL;
     fPortConnect = NULL;
+    fPortRename = NULL;
     fTimebase = NULL;
     fSync = NULL;
     fThreadFun = NULL;
@@ -72,6 +75,7 @@ JackClient::JackClient(JackSynchro* table):fThread(this)
     fClientRegistrationArg = NULL;
     fPortRegistrationArg = NULL;
     fPortConnectArg = NULL;
+    fPortRenameArg = NULL;
     fSyncArg = NULL;
     fTimebaseArg = NULL;
     fThreadFunArg = NULL;
@@ -97,6 +101,7 @@ int JackClient::Close()
     
     fChannel->Close();
     fSynchroTable[GetClientControl()->fRefNum].Disconnect();
+    fClientTable[GetClientControl()->fRefNum] = NULL;
     return result;
 }
 
@@ -237,6 +242,12 @@ int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync,
                 if (fPortConnect)
                     fPortConnect(value1, value2, 0, fPortConnectArg);
                 break;
+                
+             case kPortRenameCallback:
+                jack_log("JackClient::kPortRenameCallback src = %ld dst = %ld", value1, value2);
+                if (fPortRename)
+                    fPortRename(value1, GetGraphManager()->GetPort(value1)->GetName(), fPortRenameArg);
+                break;
 
             case kXRunCallback:
                 jack_log("JackClient::kXRunCallback");
@@ -554,6 +565,13 @@ int JackClient::PortIsMine(jack_port_id_t port_index)
     return GetClientControl()->fRefNum == port->GetRefNum();
 }
 
+int JackClient::PortRename(jack_port_id_t port_index, const char* name)
+{
+    int result = -1;
+    fChannel->PortRename(GetClientControl()->fRefNum, port_index, name, &result);
+    return result;
+}
+
 //--------------------
 // Context management
 //--------------------
@@ -880,6 +898,19 @@ int JackClient::SetPortConnectCallback(JackPortConnectCallback callback, void *a
     }
 }
 
+int JackClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg)
+{
+    if (IsActive()) {
+        jack_error("You cannot set callbacks on an active client");
+        return -1;
+    } else {
+        GetClientControl()->fCallback[kPortRenameCallback] = (callback != NULL);
+        fPortRenameArg = arg;
+        fPortRename = callback;
+        return 0;
+    }
+}
+
 int JackClient::SetProcessThread(JackThreadCallback fun, void *arg)
 {
     if (IsActive()) {

common/JackClient.h

@@ -65,6 +65,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         JackFreewheelCallback fFreewheel;
         JackPortRegistrationCallback fPortRegistration;
         JackPortConnectCallback fPortConnect;
+        JackPortRenameCallback fPortRename;
         JackTimebaseCallback fTimebase;
         JackSyncCallback fSync;
         JackThreadCallback fThreadFun;
@@ -80,6 +81,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         void* fFreewheelArg;
         void* fPortRegistrationArg;
         void* fPortConnectArg;
+        void* fPortRenameArg;
         void* fTimebaseArg;
         void* fSyncArg;
         void* fThreadFunArg;
@@ -142,6 +144,8 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         virtual int PortDisconnect(jack_port_id_t src);
 
         virtual int PortIsMine(jack_port_id_t port_index);
+        
+        virtual int PortRename(jack_port_id_t port_index, const char* name);
 
         // Transport
         virtual int ReleaseTimebase();
@@ -167,6 +171,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         virtual int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
         virtual int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
         virtual int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
+        virtual int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
 
         // Internal clients
         virtual char* GetInternalClientName(int ref);
@@ -184,6 +189,8 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         // JackRunnableInterface interface
         bool Init();
         bool Execute();
+        
+        static JackClient* fClientTable[CLIENT_NUM];
  
 };
 

common/JackDebugClient.cpp

@@ -488,6 +488,12 @@ int JackDebugClient::SetPortConnectCallback(JackPortConnectCallback callback, vo
     return fClient->SetPortConnectCallback(callback, arg);
 }
 
+int JackDebugClient::SetPortRenameCallback(JackPortRenameCallback callback, void *arg)
+{
+    CheckClient();
+    return fClient->SetPortRenameCallback(callback, arg);
+}
+
 JackClientControl* JackDebugClient::GetClientControl() const
 {
     CheckClient();

common/JackDebugClient.h

@@ -119,6 +119,7 @@ class JackDebugClient : public JackClient
         int SetFreewheelCallback(JackFreewheelCallback callback, void* arg);
         int SetPortRegistrationCallback(JackPortRegistrationCallback callback, void* arg);
         int SetPortConnectCallback(JackPortConnectCallback callback, void *arg);
+        int SetPortRenameCallback(JackPortRenameCallback callback, void *arg);
 
         // Internal clients
         char* GetInternalClientName(int ref);

common/JackEngine.cpp

@@ -319,6 +319,11 @@ void JackEngine::NotifyPortRegistation(jack_port_id_t port_index, bool onoff)
     NotifyClients((onoff ? kPortRegistrationOnCallback : kPortRegistrationOffCallback), false, port_index, 0);
 }
 
+void JackEngine::NotifyPortRename(jack_port_id_t port)
+{
+    NotifyClients(kPortRenameCallback, false, port, 0);
+}
+
 void JackEngine::NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff)
 {
     NotifyClients((onoff ? kPortConnectCallback : kPortDisconnectCallback), false, src, dst);
@@ -826,6 +831,15 @@ int JackEngine::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t ds
     }
 }
 
+int JackEngine::PortRename(int refnum, jack_port_id_t port, const char* name)
+{
+    if (fGraphManager->GetPort(port)->SetName(name) == 0) {
+        NotifyPortRename(port);
+        return 0;
+    } else {
+        return -1;
+    }
+}
 
 } // end of namespace
 

common/JackEngine.h

@@ -69,6 +69,7 @@ class EXPORT JackEngine
         void NotifyClients(int event, int sync, int value1, int value2);
         void NotifyPortRegistation(jack_port_id_t port_index, bool onoff);
         void NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff);
+        void NotifyPortRename(jack_port_id_t src);
         void NotifyActivate(int refnum);
 
     public:
@@ -106,6 +107,8 @@ class EXPORT JackEngine
 
         int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
         int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
+        
+        int PortRename(int refnum, jack_port_id_t port, const char* name);
 
         // Graph
         bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end);

common/JackInternalClient.cpp

@@ -147,6 +147,7 @@ int JackInternalClient::Open(const char* server_name, const char* name, jack_opt
     }
 
     SetupDriverSync(false);
+    fClientTable[GetClientControl()->fRefNum] = this;
     return 0;
 
 error:

common/JackLibClient.cpp

@@ -117,6 +117,7 @@ int JackLibClient::Open(const char* server_name, const char* name, jack_options_
         goto error;
     }
   
+    fClientTable[GetClientControl()->fRefNum] = this;
     jack_log("JackLibClient::Open name = %s refnum = %ld", name_res, GetClientControl()->fRefNum);
     return 0;
 

common/JackLockedEngine.h

@@ -144,6 +144,12 @@ class EXPORT JackLockedEngine : public JackLockAble
             JackLock lock(this);
             return fEngine.PortDisconnect(refnum, src, dst);
         }
+        
+        int PortRename(int refnum, jack_port_id_t port, const char* name)
+        {
+            JackLock lock(this);
+            return fEngine.PortRename(refnum, port, name);
+        }
 
         // Graph
         bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)

common/JackNotification.h

@@ -41,7 +41,8 @@ enum NotificationType {
     kPortRegistrationOffCallback = 10,
     kPortConnectCallback = 11,
     kPortDisconnectCallback = 12,
-    kRealTimeCallback = 13,
+    kPortRenameCallback = 13,
+    kRealTimeCallback = 14,
     kMaxNotification
 };
 

common/JackRequest.h

@@ -64,7 +64,8 @@ struct JackRequest
         kInternalClientHandle = 28,
         kInternalClientLoad = 29,
         kInternalClientUnload = 30,
-        kNotification = 31
+        kPortRename = 31,
+        kNotification = 32
     };
 
     RequestType fType;
@@ -590,6 +591,44 @@ struct JackPortDisconnectRequest : public JackRequest
     }
 };
 
+/*!
+\brief PortRename request.
+*/
+
+struct JackPortRenameRequest : public JackRequest
+{
+
+    int fRefNum;
+    jack_port_id_t fPort;
+    char fName[JACK_PORT_NAME_SIZE + 1];
+
+    JackPortRenameRequest()
+    {}
+    JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
+        : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
+    {
+        strcpy(fName, name);
+    }
+
+    int Read(JackChannelTransaction* trans)
+    {
+        CheckRes(trans->Read(&fRefNum, sizeof(int)));
+        CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
+        CheckRes(trans->Read(&fName, JACK_PORT_NAME_SIZE + 1));
+        return 0;
+    }
+
+    int Write(JackChannelTransaction* trans)
+    {
+        CheckRes(JackRequest::Write(trans));
+        CheckRes(trans->Write(&fRefNum, sizeof(int)));
+        CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
+        CheckRes(trans->Write(&fName, JACK_PORT_NAME_SIZE + 1));
+        return 0;
+
+    }
+};
+
 /*!
 \brief SetBufferSize request.
 */

common/JackSocketClientChannel.cpp

@@ -229,6 +229,13 @@ void JackSocketClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jac
     ServerSyncCall(&req, &res, result);
 }
 
+void JackSocketClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
+{
+    JackPortRenameRequest req(refnum, port, name);
+    JackResult res;
+    ServerSyncCall(&req, &res, result);
+}
+
 void JackSocketClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
 {
     JackSetBufferSizeRequest req(buffer_size);

common/JackSocketClientChannel.h

@@ -77,6 +77,8 @@ class JackSocketClientChannel : public detail::JackClientChannelInterface, publi
 
         void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
         void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+        
+        void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);
 
         void SetBufferSize(jack_nframes_t buffer_size, int* result);
         void SetFreewheel(int onoff, int* result);

common/JackSocketServerChannel.cpp

@@ -286,6 +286,17 @@ bool JackSocketServerChannel::HandleRequest(int fd)
                 jack_error("JackRequest::DisconnectPorts write error ref = %d", req.fRefNum);
             break;
         }
+        
+        case JackRequest::kPortRename: {
+            jack_log("JackRequest::kPortRename");
+            JackPortRenameRequest req;
+            JackResult res;
+            if (req.Read(socket) == 0)
+                res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
+            if (res.Write(socket) < 0)
+                jack_error("JackRequest::PortRename write error ref = %d", req.fRefNum);
+            break;
+        }
 
         case JackRequest::kSetBufferSize: {
             jack_log("JackRequest::SetBufferSize");

common/jack/jack.h

@@ -437,6 +437,23 @@ extern "C"
 				    JackPortConnectCallback
 				    connect_callback, void *arg);
 
+	 /**
+	 * Tell the JACK server to call @a rename_callback whenever a
+	 * port is renamed, passing @a arg as a parameter.
+	 *
+	 * All "notification events" are received in a seperated non RT thread,
+	 * the code in the supplied function does not need to be
+     * suitable for real-time execution.
+     *
+     * NOTE: this function cannot be called while the client is activated 
+     * (after jack_activate has been called.)
+     *
+	 * @return 0 on success, otherwise a non-zero error code
+	 */
+	int jack_set_port_rename_callback (jack_client_t *,
+				    JackPortRenameCallback
+				    rename_callback, void *arg);
+
     /**
      * Tell the JACK server to call @a graph_callback whenever the
      * processing graph is reordered, passing @a arg as a parameter.

common/jack/types.h

@@ -219,6 +219,18 @@ typedef void (*JackClientRegistrationCallback)(const char* name, int val, void *
  */
 typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
 
+/**
+ * Prototype for the client supplied function that is called
+ * whenever the port name has been changed.
+ *
+ * @param port the port that has been renamed
+ * @param new_name the new name
+ * @param arg pointer to a client supplied structure
+ *
+ * @return zero on success, non-zero on error
+ */
+typedef int (*JackPortRenameCallback)(jack_port_id_t port, const char* new_name, void *arg);
+
 /**
  * Prototype for the client supplied function that is called
  * whenever jackd starts or stops freewheeling.
@@ -228,7 +240,6 @@ typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int
  */
 typedef void (*JackFreewheelCallback)(int starting, void *arg);
 
-
 /**
  * Used for the type argument of jack_port_register() for default
  * audio ports and midi ports.

macosx/JackMacEngineRPC.cpp

@@ -139,6 +139,15 @@ rpc_type server_rpc_jack_port_disconnect(mach_port_t private_port, int refnum, i
     return KERN_SUCCESS;
 }
 
+rpc_type server_rpc_jack_port_rename(mach_port_t private_port, int refnum, int port, client_port_name_t name, int* result)
+{
+    jack_log("server_rpc_jack_port_rename");
+    JackMachServerChannel* channel = JackMachServerChannel::fPortTable[private_port];
+    assert(channel);
+    *result = channel->GetEngine()->PortRename(refnum, port, name);
+    return KERN_SUCCESS;
+}
+
 //------------------------
 // Buffer size, freewheel
 //------------------------

macosx/JackMachClientChannel.cpp

@@ -226,6 +226,15 @@ void JackMachClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jack_
     }
 }
 
+void JackMachClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
+{
+    kern_return_t res = rpc_jack_port_rename(fPrivatePort, refnum, port, (char*)name, result);
+    if (res != KERN_SUCCESS) {
+        *result = -1;
+        jack_error("JackMachClientChannel::PortRename err = %s", mach_error_string(res));
+    }
+}
+
 void JackMachClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
 {
     kern_return_t res = rpc_jack_set_buffer_size(fPrivatePort, buffer_size, result);

macosx/JackMachClientChannel.h

@@ -73,6 +73,8 @@ class JackMachClientChannel : public detail::JackClientChannelInterface, public
 
         void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
         void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+        
+        void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);
 
         void SetBufferSize(jack_nframes_t buffer_size, int* result);
         void SetFreewheel(int onoff, int* result);

macosx/RPC/JackRPCClientServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Wed May 21 10:43:25 2008
+ * stub generated Mon Sep  1 17:42:27 2008
  * with a MiG generated Tue Feb 19 02:01:43 PST 2008 by root@b75.local
  * OPTIONS: 
  */

macosx/RPC/JackRPCClientUser.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Wed May 21 10:43:25 2008
+ * stub generated Mon Sep  1 17:42:27 2008
  * with a MiG generated Tue Feb 19 02:01:43 PST 2008 by root@b75.local
  * OPTIONS: 
  */

macosx/RPC/JackRPCEngine.defs

@@ -85,34 +85,41 @@ routine rpc_jack_port_unregister(
 routine rpc_jack_port_connect(
 	server_port	: mach_port_t;
 	refnum		: int;
-	src         : int;
-	dst         : int;
+	src         	: int;
+	dst         	: int;
 	out result 	: int);
 	
 routine rpc_jack_port_disconnect(
 	server_port	: mach_port_t;
 	refnum		: int;
-	src         : int;
-	dst         : int;
+	src         	: int;
+	dst         	: int;
 	out result 	: int);
     
 routine rpc_jack_port_connect_name(
 	server_port	: mach_port_t;
 	refnum		: int;
-	src         : client_port_name_t;
-	dst         : client_port_name_t;
+	src         	: client_port_name_t;
+	dst         	: client_port_name_t;
 	out result 	: int);
 	
 routine rpc_jack_port_disconnect_name(
 	server_port	: mach_port_t;
 	refnum		: int;
-	src         : client_port_name_t;
-	dst         : client_port_name_t;
+	src         	: client_port_name_t;
+	dst         	: client_port_name_t;
 	out result 	: int);
 	
+routine rpc_jack_port_rename(
+	server_port	: mach_port_t;
+	refnum		: int;
+	src         	: int;
+	name        	: client_port_name_t;
+	out result 	: int);
+
 routine rpc_jack_set_buffer_size(
 	server_port	: mach_port_t;
-	buffer_size : int;
+	buffer_size 	: int;
 	out result 	: int);
 	
 routine rpc_jack_set_freewheel(
@@ -142,9 +149,9 @@ routine rpc_jack_internal_clienthandle(
 	server_port	: mach_port_t;
 	refnum		: int;
 	client_name	: client_name_t;
-	out int_ref : int;
+	out int_ref 	: int;
 	out status	: int;
-	out result : int);
+	out result 	: int);
 	
 routine rpc_jack_internal_clientload(
 	server_port	: mach_port_t;
@@ -154,7 +161,7 @@ routine rpc_jack_internal_clientload(
 	objet_data	: objet_data_t;
 	options		: int;
 	out status	: int;
-	out int_ref : int;
+	out int_ref 	: int;
 	out result	: int);
 	
 routine rpc_jack_internal_clientunload(
@@ -168,7 +175,7 @@ simpleroutine rpc_jack_client_rt_notify(
 	client_port	: mach_port_t;
 	refnum		: int;
 	notify		: int;
-    value		: int;
+    	value		: int;
 	waittime timeout : int);
 
 	

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	20
+#define	JackRPCEngine_MSG_COUNT	21
 #endif	/* JackRPCEngine_MSG_COUNT */
 
 #include <mach/std_types.h>
@@ -210,6 +210,21 @@ kern_return_t rpc_jack_port_disconnect_name
 	int *result
 );
 
+/* Routine rpc_jack_port_rename */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t rpc_jack_port_rename
+(
+	mach_port_t server_port,
+	int refnum,
+	int src,
+	client_port_name_t name,
+	int *result
+);
+
 /* Routine rpc_jack_set_buffer_size */
 #ifdef	mig_external
 mig_external
@@ -510,6 +525,20 @@ __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 src;
+		client_port_name_t name;
+	} __Request__rpc_jack_port_rename_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -645,6 +674,7 @@ union __RequestUnion__JackRPCEngine_subsystem {
 	__Request__rpc_jack_port_disconnect_t Request_rpc_jack_port_disconnect;
 	__Request__rpc_jack_port_connect_name_t Request_rpc_jack_port_connect_name;
 	__Request__rpc_jack_port_disconnect_name_t Request_rpc_jack_port_disconnect_name;
+	__Request__rpc_jack_port_rename_t Request_rpc_jack_port_rename;
 	__Request__rpc_jack_set_buffer_size_t Request_rpc_jack_set_buffer_size;
 	__Request__rpc_jack_set_freewheel_t Request_rpc_jack_set_freewheel;
 	__Request__rpc_jack_release_timebase_t Request_rpc_jack_release_timebase;
@@ -813,6 +843,19 @@ 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;
+		int result;
+	} __Reply__rpc_jack_port_rename_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -952,6 +995,7 @@ union __ReplyUnion__JackRPCEngine_subsystem {
 	__Reply__rpc_jack_port_disconnect_t Reply_rpc_jack_port_disconnect;
 	__Reply__rpc_jack_port_connect_name_t Reply_rpc_jack_port_connect_name;
 	__Reply__rpc_jack_port_disconnect_name_t Reply_rpc_jack_port_disconnect_name;
+	__Reply__rpc_jack_port_rename_t Reply_rpc_jack_port_rename;
 	__Reply__rpc_jack_set_buffer_size_t Reply_rpc_jack_set_buffer_size;
 	__Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel;
 	__Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase;
@@ -977,15 +1021,16 @@ union __ReplyUnion__JackRPCEngine_subsystem {
     { "rpc_jack_port_disconnect", 1008 },\
     { "rpc_jack_port_connect_name", 1009 },\
     { "rpc_jack_port_disconnect_name", 1010 },\
-    { "rpc_jack_set_buffer_size", 1011 },\
-    { "rpc_jack_set_freewheel", 1012 },\
-    { "rpc_jack_release_timebase", 1013 },\
-    { "rpc_jack_set_timebase_callback", 1014 },\
-    { "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 }
+    { "rpc_jack_port_rename", 1011 },\
+    { "rpc_jack_set_buffer_size", 1012 },\
+    { "rpc_jack_set_freewheel", 1013 },\
+    { "rpc_jack_release_timebase", 1014 },\
+    { "rpc_jack_set_timebase_callback", 1015 },\
+    { "rpc_jack_get_internal_clientname", 1016 },\
+    { "rpc_jack_internal_clienthandle", 1017 },\
+    { "rpc_jack_internal_clientload", 1018 },\
+    { "rpc_jack_internal_clientunload", 1019 },\
+    { "rpc_jack_client_rt_notify", 1020 }
 #endif
 
 #ifdef __AfterMigUserHeader

macosx/RPC/JackRPCEngineServer.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Wed May 21 10:43:25 2008
+ * stub generated Mon Sep  1 17:42:28 2008
  * with a MiG generated Tue Feb 19 02:01:43 PST 2008 by root@b75.local
  * OPTIONS: 
  */
@@ -253,6 +253,20 @@
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		int refnum;
+		int src;
+		client_port_name_t name;
+	} __Request__rpc_jack_port_rename_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -529,6 +543,19 @@
 #pragma pack()
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int result;
+	} __Reply__rpc_jack_port_rename_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(4)
 #endif
@@ -669,6 +696,7 @@ union __ReplyUnion__server_JackRPCEngine_subsystem {
 	__Reply__rpc_jack_port_disconnect_t Reply_rpc_jack_port_disconnect;
 	__Reply__rpc_jack_port_connect_name_t Reply_rpc_jack_port_connect_name;
 	__Reply__rpc_jack_port_disconnect_name_t Reply_rpc_jack_port_disconnect_name;
+	__Reply__rpc_jack_port_rename_t Reply_rpc_jack_port_rename;
 	__Reply__rpc_jack_set_buffer_size_t Reply_rpc_jack_set_buffer_size;
 	__Reply__rpc_jack_set_freewheel_t Reply_rpc_jack_set_freewheel;
 	__Reply__rpc_jack_release_timebase_t Reply_rpc_jack_release_timebase;
@@ -716,6 +744,9 @@ mig_internal novalue _Xrpc_jack_port_connect_name
 mig_internal novalue _Xrpc_jack_port_disconnect_name
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
 
+mig_internal novalue _Xrpc_jack_port_rename
+	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
+
 mig_internal novalue _Xrpc_jack_set_buffer_size
 	(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP);
 
@@ -3944,6 +3975,328 @@ mig_internal novalue _Xrpc_jack_port_disconnect_name
 	__AfterRcvRpc(1010, "rpc_jack_port_disconnect_name")
 }
 
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Request__JackRPCEngine_subsystem__
+#if !defined(__MIG_check__Request__rpc_jack_port_rename_t__defined)
+#define __MIG_check__Request__rpc_jack_port_rename_t__defined
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined */
+
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined */
+
+#ifndef __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__client_port_name_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__int_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__client_port_name_t__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__int_rep__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__int_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__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_port_rename_t__name__defined
+#define	__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__int_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined */
+
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined */
+
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined */
+
+#ifndef __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__client_port_name_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__char_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__client_port_name_t__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__char_rep__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__char_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__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_port_rename_t__name__defined
+#define	__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__char_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined */
+
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined */
+
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(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_port_rename_t__src__defined */
+
+#ifndef __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__client_port_name_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__float_rep__JackRPCEngine__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__client_port_name_t__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__float_rep__client_port_name_t((client_port_name_t *)(a), f)
+#elif	defined(__NDR_convert__float_rep__JackRPCEngine__string__defined)
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__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_port_rename_t__name__defined
+#define	__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(a, f) \
+	__NDR_convert__float_rep__string(a, f, 128)
+#endif /* defined(__NDR_convert__*__defined) */
+#endif /* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined */
+
+
+mig_internal kern_return_t __MIG_check__Request__rpc_jack_port_rename_t(__attribute__((__unused__)) __Request__rpc_jack_port_rename_t *In0P)
+{
+
+	typedef __Request__rpc_jack_port_rename_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_port_rename_t__refnum__defined) || \
+	defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+	defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined)
+	if (In0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__src__defined */
+#if defined(__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined)
+		__NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.int_rep);
+#endif	/* __NDR_convert__int_rep__Request__rpc_jack_port_rename_t__name__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined) || \
+	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+	defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined)
+	if (In0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__src__defined */
+#if defined(__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined)
+		__NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.char_rep);
+#endif	/* __NDR_convert__char_rep__Request__rpc_jack_port_rename_t__name__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined) || \
+	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined) || \
+	defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined)
+	if (In0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum(&In0P->refnum, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__refnum__defined */
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src(&In0P->src, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__src__defined */
+#if defined(__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined)
+		__NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name(&In0P->name, In0P->NDR.float_rep);
+#endif	/* __NDR_convert__float_rep__Request__rpc_jack_port_rename_t__name__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Request__rpc_jack_port_rename_t__defined) */
+#endif /* __MIG_check__Request__JackRPCEngine_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine rpc_jack_port_rename */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t server_rpc_jack_port_rename
+(
+	mach_port_t server_port,
+	int refnum,
+	int src,
+	client_port_name_t name,
+	int *result
+);
+
+/* Routine rpc_jack_port_rename */
+mig_internal novalue _Xrpc_jack_port_rename
+	(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 src;
+		client_port_name_t name;
+		mach_msg_trailer_t trailer;
+	} Request;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	typedef __Request__rpc_jack_port_rename_t __Request;
+	typedef __Reply__rpc_jack_port_rename_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_port_rename_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Request__rpc_jack_port_rename_t__defined */
+
+	__DeclareRcvRpc(1011, "rpc_jack_port_rename")
+	__BeforeRcvRpc(1011, "rpc_jack_port_rename")
+
+#if	defined(__MIG_check__Request__rpc_jack_port_rename_t__defined)
+	check_result = __MIG_check__Request__rpc_jack_port_rename_t((__Request *)In0P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ MIG_RETURN_ERROR(OutP, check_result); }
+#endif	/* defined(__MIG_check__Request__rpc_jack_port_rename_t__defined) */
+
+	OutP->RetCode = server_rpc_jack_port_rename(In0P->Head.msgh_request_port, In0P->refnum, In0P->src, In0P->name, &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(1011, "rpc_jack_port_rename")
+}
+
 #if ( __MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Request__JackRPCEngine_subsystem__
 #if !defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined)
@@ -4097,8 +4450,8 @@ mig_internal novalue _Xrpc_jack_set_buffer_size
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_buffer_size_t__defined */
 
-	__DeclareRcvRpc(1011, "rpc_jack_set_buffer_size")
-	__BeforeRcvRpc(1011, "rpc_jack_set_buffer_size")
+	__DeclareRcvRpc(1012, "rpc_jack_set_buffer_size")
+	__BeforeRcvRpc(1012, "rpc_jack_set_buffer_size")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_buffer_size_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_buffer_size_t((__Request *)In0P);
@@ -4115,7 +4468,7 @@ mig_internal novalue _Xrpc_jack_set_buffer_size
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1011, "rpc_jack_set_buffer_size")
+	__AfterRcvRpc(1012, "rpc_jack_set_buffer_size")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -4271,8 +4624,8 @@ mig_internal novalue _Xrpc_jack_set_freewheel
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_freewheel_t__defined */
 
-	__DeclareRcvRpc(1012, "rpc_jack_set_freewheel")
-	__BeforeRcvRpc(1012, "rpc_jack_set_freewheel")
+	__DeclareRcvRpc(1013, "rpc_jack_set_freewheel")
+	__BeforeRcvRpc(1013, "rpc_jack_set_freewheel")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_freewheel_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_freewheel_t((__Request *)In0P);
@@ -4289,7 +4642,7 @@ mig_internal novalue _Xrpc_jack_set_freewheel
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1012, "rpc_jack_set_freewheel")
+	__AfterRcvRpc(1013, "rpc_jack_set_freewheel")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -4445,8 +4798,8 @@ mig_internal novalue _Xrpc_jack_release_timebase
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_release_timebase_t__defined */
 
-	__DeclareRcvRpc(1013, "rpc_jack_release_timebase")
-	__BeforeRcvRpc(1013, "rpc_jack_release_timebase")
+	__DeclareRcvRpc(1014, "rpc_jack_release_timebase")
+	__BeforeRcvRpc(1014, "rpc_jack_release_timebase")
 
 #if	defined(__MIG_check__Request__rpc_jack_release_timebase_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_release_timebase_t((__Request *)In0P);
@@ -4463,7 +4816,7 @@ mig_internal novalue _Xrpc_jack_release_timebase
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1013, "rpc_jack_release_timebase")
+	__AfterRcvRpc(1014, "rpc_jack_release_timebase")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -4693,8 +5046,8 @@ mig_internal novalue _Xrpc_jack_set_timebase_callback
 	kern_return_t check_result;
 #endif	/* __MIG_check__Request__rpc_jack_set_timebase_callback_t__defined */
 
-	__DeclareRcvRpc(1014, "rpc_jack_set_timebase_callback")
-	__BeforeRcvRpc(1014, "rpc_jack_set_timebase_callback")
+	__DeclareRcvRpc(1015, "rpc_jack_set_timebase_callback")
+	__BeforeRcvRpc(1015, "rpc_jack_set_timebase_callback")
 
 #if	defined(__MIG_check__Request__rpc_jack_set_timebase_callback_t__defined)
 	check_result = __MIG_check__Request__rpc_jack_set_timebase_callback_t((__Request *)In0P);
@@ -4711,7 +5064,7 @@ mig_internal novalue _Xrpc_jack_set_timebase_callback
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1014, "rpc_jack_set_timebase_callback")
+	__AfterRcvRpc(1015, "rpc_jack_set_timebase_callback")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -4942,8 +5295,8 @@ mig_internal novalue _Xrpc_jack_get_internal_clientname
 	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")
+	__DeclareRcvRpc(1016, "rpc_jack_get_internal_clientname")
+	__BeforeRcvRpc(1016, "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);
@@ -4960,7 +5313,7 @@ mig_internal novalue _Xrpc_jack_get_internal_clientname
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1015, "rpc_jack_get_internal_clientname")
+	__AfterRcvRpc(1016, "rpc_jack_get_internal_clientname")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -5192,8 +5545,8 @@ mig_internal novalue _Xrpc_jack_internal_clienthandle
 	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")
+	__DeclareRcvRpc(1017, "rpc_jack_internal_clienthandle")
+	__BeforeRcvRpc(1017, "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);
@@ -5210,7 +5563,7 @@ mig_internal novalue _Xrpc_jack_internal_clienthandle
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1016, "rpc_jack_internal_clienthandle")
+	__AfterRcvRpc(1017, "rpc_jack_internal_clienthandle")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -5664,8 +6017,8 @@ mig_internal novalue _Xrpc_jack_internal_clientload
 	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")
+	__DeclareRcvRpc(1018, "rpc_jack_internal_clientload")
+	__BeforeRcvRpc(1018, "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);
@@ -5682,7 +6035,7 @@ mig_internal novalue _Xrpc_jack_internal_clientload
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1017, "rpc_jack_internal_clientload")
+	__AfterRcvRpc(1018, "rpc_jack_internal_clientload")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -5913,8 +6266,8 @@ mig_internal novalue _Xrpc_jack_internal_clientunload
 	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")
+	__DeclareRcvRpc(1019, "rpc_jack_internal_clientunload")
+	__BeforeRcvRpc(1019, "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);
@@ -5931,7 +6284,7 @@ mig_internal novalue _Xrpc_jack_internal_clientunload
 
 
 	OutP->Head.msgh_size = (mach_msg_size_t)(sizeof(Reply));
-	__AfterRcvRpc(1018, "rpc_jack_internal_clientunload")
+	__AfterRcvRpc(1019, "rpc_jack_internal_clientunload")
 }
 
 #if ( __MigTypeCheck || __NDR_convert__ )
@@ -6234,8 +6587,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(1019, "rpc_jack_client_rt_notify")
-	__BeforeRcvSimple(1019, "rpc_jack_client_rt_notify")
+	__DeclareRcvSimple(1020, "rpc_jack_client_rt_notify")
+	__BeforeRcvSimple(1020, "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);
@@ -6244,7 +6597,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(1019, "rpc_jack_client_rt_notify")
+	__AfterRcvSimple(1020, "rpc_jack_client_rt_notify")
 }
 
 
@@ -6264,11 +6617,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[20];
+		routine[21];
 } server_JackRPCEngine_subsystem = {
 	JackRPCEngine_server_routine,
 	1000,
-	1020,
+	1021,
 	(mach_msg_size_t)sizeof(union __ReplyUnion__server_JackRPCEngine_subsystem),
 	(vm_address_t)0,
 	{
@@ -6294,6 +6647,8 @@ const struct server_JackRPCEngine_subsystem {
             (mig_stub_routine_t) _Xrpc_jack_port_connect_name, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_connect_name_t)},
           { (mig_impl_routine_t) 0,
             (mig_stub_routine_t) _Xrpc_jack_port_disconnect_name, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_disconnect_name_t)},
+          { (mig_impl_routine_t) 0,
+            (mig_stub_routine_t) _Xrpc_jack_port_rename, 5, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_port_rename_t)},
           { (mig_impl_routine_t) 0,
             (mig_stub_routine_t) _Xrpc_jack_set_buffer_size, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__rpc_jack_set_buffer_size_t)},
           { (mig_impl_routine_t) 0,
@@ -6335,7 +6690,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 > 1019) || (InHeadP->msgh_id < 1000) ||
+	if ((InHeadP->msgh_id > 1020) || (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;
@@ -6352,7 +6707,7 @@ mig_external mig_routine_t JackRPCEngine_server_routine
 
 	msgh_id = InHeadP->msgh_id - 1000;
 
-	if ((msgh_id > 19) || (msgh_id < 0))
+	if ((msgh_id > 20) || (msgh_id < 0))
 		return 0;
 
 	return server_JackRPCEngine_subsystem.routine[msgh_id].stub_routine;

macosx/RPC/JackRPCEngineUser.c

@@ -1,6 +1,6 @@
 /*
  * IDENTIFICATION:
- * stub generated Wed May 21 10:43:25 2008
+ * stub generated Mon Sep  1 17:42:28 2008
  * with a MiG generated Tue Feb 19 02:01:43 PST 2008 by root@b75.local
  * OPTIONS: 
  */
@@ -3433,6 +3433,267 @@ mig_external kern_return_t rpc_jack_port_disconnect_name
 	return KERN_SUCCESS;
 }
 
+#if ( __MigTypeCheck || __NDR_convert__ )
+#if __MIG_check__Reply__JackRPCEngine_subsystem__
+#if !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
+#define __MIG_check__Reply__rpc_jack_port_rename_t__defined
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__kern_return_t__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__RetCode__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__RetCode__defined */
+
+
+#ifndef __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+#if	defined(__NDR_convert__int_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__int_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined */
+
+
+
+#ifndef __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+#if	defined(__NDR_convert__char_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__char_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined */
+
+
+
+#ifndef __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+#if	defined(__NDR_convert__float_rep__JackRPCEngine__int__defined)
+#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined
+#define	__NDR_convert__float_rep__Reply__rpc_jack_port_rename_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_port_rename_t__result__defined */
+
+
+
+mig_internal kern_return_t __MIG_check__Reply__rpc_jack_port_rename_t(__Reply__rpc_jack_port_rename_t *Out0P)
+{
+
+	typedef __Reply__rpc_jack_port_rename_t __Reply;
+#if	__MigTypeCheck
+	unsigned int msgh_size;
+#endif	/* __MigTypeCheck */
+	if (Out0P->Head.msgh_id != 1111) {
+	    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_port_rename_t__RetCode__defined) || \
+	defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
+	if (Out0P->NDR.int_rep != NDR_record.int_rep) {
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode(&Out0P->RetCode, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__RetCode__defined */
+#if defined(__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined)
+		__NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.int_rep);
+#endif /* __NDR_convert__int_rep__Reply__rpc_jack_port_rename_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__int_rep...) */
+
+#if	0 || \
+	defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
+	if (Out0P->NDR.char_rep != NDR_record.char_rep) {
+#if defined(__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined)
+		__NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.char_rep);
+#endif /* __NDR_convert__char_rep__Reply__rpc_jack_port_rename_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__char_rep...) */
+
+#if	0 || \
+	defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
+	if (Out0P->NDR.float_rep != NDR_record.float_rep) {
+#if defined(__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined)
+		__NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result(&Out0P->result, Out0P->NDR.float_rep);
+#endif /* __NDR_convert__float_rep__Reply__rpc_jack_port_rename_t__result__defined */
+	}
+#endif	/* defined(__NDR_convert__float_rep...) */
+
+	return MACH_MSG_SUCCESS;
+}
+#endif /* !defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
+#endif /* __MIG_check__Reply__JackRPCEngine_subsystem__ */
+#endif /* ( __MigTypeCheck || __NDR_convert__ ) */
+
+
+/* Routine rpc_jack_port_rename */
+mig_external kern_return_t rpc_jack_port_rename
+(
+	mach_port_t server_port,
+	int refnum,
+	int src,
+	client_port_name_t name,
+	int *result
+)
+{
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		int refnum;
+		int src;
+		client_port_name_t 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 result;
+		mach_msg_trailer_t trailer;
+	} Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int result;
+	} __Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+	/*
+	 * typedef struct {
+	 * 	mach_msg_header_t Head;
+	 * 	NDR_record_t NDR;
+	 * 	kern_return_t RetCode;
+	 * } mig_reply_error_t;
+	 */
+
+	union {
+		Request In;
+		Reply Out;
+	} Mess;
+
+	Request *InP = &Mess.In;
+	Reply *Out0P = &Mess.Out;
+
+	mach_msg_return_t msg_result;
+
+#ifdef	__MIG_check__Reply__rpc_jack_port_rename_t__defined
+	kern_return_t check_result;
+#endif	/* __MIG_check__Reply__rpc_jack_port_rename_t__defined */
+
+	__DeclareSendRpc(1011, "rpc_jack_port_rename")
+
+	InP->NDR = NDR_record;
+
+	InP->refnum = refnum;
+
+	InP->src = src;
+
+	(void) mig_strncpy(InP->name, 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 = 1011;
+
+	__BeforeSendRpc(1011, "rpc_jack_port_rename")
+	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(1011, "rpc_jack_port_rename")
+	if (msg_result != MACH_MSG_SUCCESS) {
+		__MachMsgErrorWithoutTimeout(msg_result);
+		{ return msg_result; }
+	}
+
+
+#if	defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined)
+	check_result = __MIG_check__Reply__rpc_jack_port_rename_t((__Reply__rpc_jack_port_rename_t *)Out0P);
+	if (check_result != MACH_MSG_SUCCESS)
+		{ return check_result; }
+#endif	/* defined(__MIG_check__Reply__rpc_jack_port_rename_t__defined) */
+
+	*result = Out0P->result;
+
+	return KERN_SUCCESS;
+}
+
 #if ( __MigTypeCheck || __NDR_convert__ )
 #if __MIG_check__Reply__JackRPCEngine_subsystem__
 #if !defined(__MIG_check__Reply__rpc_jack_set_buffer_size_t__defined)
@@ -3523,7 +3784,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_buffer_size_t(__Repl
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1111) {
+	if (Out0P->Head.msgh_id != 1112) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -3653,7 +3914,7 @@ mig_external kern_return_t rpc_jack_set_buffer_size
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_buffer_size_t__defined */
 
-	__DeclareSendRpc(1011, "rpc_jack_set_buffer_size")
+	__DeclareSendRpc(1012, "rpc_jack_set_buffer_size")
 
 	InP->NDR = NDR_record;
 
@@ -3664,11 +3925,11 @@ mig_external kern_return_t rpc_jack_set_buffer_size
 	/* 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 = 1011;
+	InP->Head.msgh_id = 1012;
 
-	__BeforeSendRpc(1011, "rpc_jack_set_buffer_size")
+	__BeforeSendRpc(1012, "rpc_jack_set_buffer_size")
 	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(1011, "rpc_jack_set_buffer_size")
+	__AfterSendRpc(1012, "rpc_jack_set_buffer_size")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -3776,7 +4037,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_freewheel_t(__Reply_
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1112) {
+	if (Out0P->Head.msgh_id != 1113) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -3906,7 +4167,7 @@ mig_external kern_return_t rpc_jack_set_freewheel
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_freewheel_t__defined */
 
-	__DeclareSendRpc(1012, "rpc_jack_set_freewheel")
+	__DeclareSendRpc(1013, "rpc_jack_set_freewheel")
 
 	InP->NDR = NDR_record;
 
@@ -3917,11 +4178,11 @@ mig_external kern_return_t rpc_jack_set_freewheel
 	/* 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 = 1012;
+	InP->Head.msgh_id = 1013;
 
-	__BeforeSendRpc(1012, "rpc_jack_set_freewheel")
+	__BeforeSendRpc(1013, "rpc_jack_set_freewheel")
 	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(1012, "rpc_jack_set_freewheel")
+	__AfterSendRpc(1013, "rpc_jack_set_freewheel")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -4029,7 +4290,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_release_timebase_t(__Rep
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1113) {
+	if (Out0P->Head.msgh_id != 1114) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -4159,7 +4420,7 @@ mig_external kern_return_t rpc_jack_release_timebase
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_release_timebase_t__defined */
 
-	__DeclareSendRpc(1013, "rpc_jack_release_timebase")
+	__DeclareSendRpc(1014, "rpc_jack_release_timebase")
 
 	InP->NDR = NDR_record;
 
@@ -4170,11 +4431,11 @@ mig_external kern_return_t rpc_jack_release_timebase
 	/* 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 = 1013;
+	InP->Head.msgh_id = 1014;
 
-	__BeforeSendRpc(1013, "rpc_jack_release_timebase")
+	__BeforeSendRpc(1014, "rpc_jack_release_timebase")
 	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(1013, "rpc_jack_release_timebase")
+	__AfterSendRpc(1014, "rpc_jack_release_timebase")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -4282,7 +4543,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_set_timebase_callback_t(
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1114) {
+	if (Out0P->Head.msgh_id != 1115) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -4414,7 +4675,7 @@ mig_external kern_return_t rpc_jack_set_timebase_callback
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_set_timebase_callback_t__defined */
 
-	__DeclareSendRpc(1014, "rpc_jack_set_timebase_callback")
+	__DeclareSendRpc(1015, "rpc_jack_set_timebase_callback")
 
 	InP->NDR = NDR_record;
 
@@ -4427,11 +4688,11 @@ mig_external kern_return_t rpc_jack_set_timebase_callback
 	/* 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 = 1014;
+	InP->Head.msgh_id = 1015;
 
-	__BeforeSendRpc(1014, "rpc_jack_set_timebase_callback")
+	__BeforeSendRpc(1015, "rpc_jack_set_timebase_callback")
 	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(1014, "rpc_jack_set_timebase_callback")
+	__AfterSendRpc(1015, "rpc_jack_set_timebase_callback")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -4602,7 +4863,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_get_internal_clientname_
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1115) {
+	if (Out0P->Head.msgh_id != 1116) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -4749,7 +5010,7 @@ mig_external kern_return_t rpc_jack_get_internal_clientname
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_get_internal_clientname_t__defined */
 
-	__DeclareSendRpc(1015, "rpc_jack_get_internal_clientname")
+	__DeclareSendRpc(1016, "rpc_jack_get_internal_clientname")
 
 	InP->NDR = NDR_record;
 
@@ -4762,11 +5023,11 @@ mig_external kern_return_t rpc_jack_get_internal_clientname
 	/* 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;
+	InP->Head.msgh_id = 1016;
 
-	__BeforeSendRpc(1015, "rpc_jack_get_internal_clientname")
+	__BeforeSendRpc(1016, "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")
+	__AfterSendRpc(1016, "rpc_jack_get_internal_clientname")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -5002,7 +5263,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clienthandle_t(
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1116) {
+	if (Out0P->Head.msgh_id != 1117) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -5164,7 +5425,7 @@ mig_external kern_return_t rpc_jack_internal_clienthandle
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_internal_clienthandle_t__defined */
 
-	__DeclareSendRpc(1016, "rpc_jack_internal_clienthandle")
+	__DeclareSendRpc(1017, "rpc_jack_internal_clienthandle")
 
 	InP->NDR = NDR_record;
 
@@ -5177,11 +5438,11 @@ mig_external kern_return_t rpc_jack_internal_clienthandle
 	/* 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;
+	InP->Head.msgh_id = 1017;
 
-	__BeforeSendRpc(1016, "rpc_jack_internal_clienthandle")
+	__BeforeSendRpc(1017, "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")
+	__AfterSendRpc(1017, "rpc_jack_internal_clienthandle")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -5419,7 +5680,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientload_t(__
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1117) {
+	if (Out0P->Head.msgh_id != 1118) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -5587,7 +5848,7 @@ mig_external kern_return_t rpc_jack_internal_clientload
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_internal_clientload_t__defined */
 
-	__DeclareSendRpc(1017, "rpc_jack_internal_clientload")
+	__DeclareSendRpc(1018, "rpc_jack_internal_clientload")
 
 	InP->NDR = NDR_record;
 
@@ -5606,11 +5867,11 @@ mig_external kern_return_t rpc_jack_internal_clientload
 	/* 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;
+	InP->Head.msgh_id = 1018;
 
-	__BeforeSendRpc(1017, "rpc_jack_internal_clientload")
+	__BeforeSendRpc(1018, "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")
+	__AfterSendRpc(1018, "rpc_jack_internal_clientload")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -5785,7 +6046,7 @@ mig_internal kern_return_t __MIG_check__Reply__rpc_jack_internal_clientunload_t(
 #if	__MigTypeCheck
 	unsigned int msgh_size;
 #endif	/* __MigTypeCheck */
-	if (Out0P->Head.msgh_id != 1118) {
+	if (Out0P->Head.msgh_id != 1119) {
 	    if (Out0P->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)
 		{ return MIG_SERVER_DIED; }
 	    else
@@ -5932,7 +6193,7 @@ mig_external kern_return_t rpc_jack_internal_clientunload
 	kern_return_t check_result;
 #endif	/* __MIG_check__Reply__rpc_jack_internal_clientunload_t__defined */
 
-	__DeclareSendRpc(1018, "rpc_jack_internal_clientunload")
+	__DeclareSendRpc(1019, "rpc_jack_internal_clientunload")
 
 	InP->NDR = NDR_record;
 
@@ -5945,11 +6206,11 @@ mig_external kern_return_t rpc_jack_internal_clientunload
 	/* 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;
+	InP->Head.msgh_id = 1019;
 
-	__BeforeSendRpc(1018, "rpc_jack_internal_clientunload")
+	__BeforeSendRpc(1019, "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")
+	__AfterSendRpc(1019, "rpc_jack_internal_clientunload")
 	if (msg_result != MACH_MSG_SUCCESS) {
 		__MachMsgErrorWithoutTimeout(msg_result);
 		{ return msg_result; }
@@ -6013,7 +6274,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(1019, "rpc_jack_client_rt_notify")
+	__DeclareSendSimple(1020, "rpc_jack_client_rt_notify")
 
 	InP->NDR = NDR_record;
 
@@ -6028,11 +6289,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 = 1019;
+	InP->Head.msgh_id = 1020;
 
-	__BeforeSendSimple(1019, "rpc_jack_client_rt_notify")
+	__BeforeSendSimple(1020, "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(1019, "rpc_jack_client_rt_notify")
+	__AfterSendSimple(1020, "rpc_jack_client_rt_notify")
 
 	if (msg_result == MACH_SEND_TIMED_OUT) {
 	}

windows/JackWinNamedPipeClientChannel.cpp

@@ -229,6 +229,13 @@ void JackWinNamedPipeClientChannel::PortDisconnect(int refnum, jack_port_id_t sr
     ServerSyncCall(&req, &res, result);
 }
 
+void JackWinNamedPipeClientChannel::PortRename(int refnum, jack_port_id_t port, const char* name, int* result)
+{
+    JackPortRenameRequest req(refnum, port, name);
+    JackResult res;
+    ServerSyncCall(&req, &res, result);
+}
+
 void JackWinNamedPipeClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
 {
     JackSetBufferSizeRequest req(buffer_size);

windows/JackWinNamedPipeClientChannel.h

@@ -75,6 +75,8 @@ class JackWinNamedPipeClientChannel : public detail::JackClientChannelInterface,
 
         void PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
         void PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result);
+        
+        void PortRename(int refnum, jack_port_id_t port, const char* name, int* result);
 
         void SetBufferSize(jack_nframes_t buffer_size, int* result);
         void SetFreewheel(int onoff, int* result);

windows/JackWinNamedPipeServerChannel.cpp

@@ -220,6 +220,16 @@ bool JackClientPipeThread::HandleRequest()
                 res.Write(fPipe);
                 break;
             }
+            
+            case JackRequest::kPortRename: {
+                jack_log("JackRequest::kPortRename");
+                JackPortRenameRequest req;
+                JackResult res;
+                if (req.Read(fPipe) == 0)
+                    res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
+                res.Write(fPipe);
+                break;
+            }
 
             case JackRequest::kSetBufferSize: {
                 jack_log("JackRequest::SetBufferSize");