Rename functions from k5_ipc_stream_* to krb5int_ipc_stream_*, because some of them will have to be exported

git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@21938 dc483132-0cff-0310-8789-dd5450dbe970

3 files changed, 64 insertions, 64 deletions

diff --git a/src/util/mac/k5_mig_client.c b/src/util/mac/k5_mig_client.c
index 7dedbbe..603ffdc 100644
--- a/src/util/mac/k5_mig_client.c
+++ b/src/util/mac/k5_mig_client.c
@@ -325,12 +325,12 @@ kern_return_t k5_ipc_client_reply (mach_port_t             in_reply_port,
     
     if (!err) {
         if (in_inl_replyCnt) {
-            err = k5_ipc_stream_write (cinfo->reply_stream, 
-                                       in_inl_reply, in_inl_replyCnt);
+            err = krb5int_ipc_stream_write (cinfo->reply_stream, 
+					    in_inl_reply, in_inl_replyCnt);
             
         } else if (in_ool_replyCnt) {
-            err = k5_ipc_stream_write (cinfo->reply_stream, 
-                                       in_ool_reply, in_ool_replyCnt);
+            err = krb5int_ipc_stream_write (cinfo->reply_stream, 
+					    in_ool_reply, in_ool_replyCnt);
             
         } else {
             err = EINVAL;
@@ -375,14 +375,14 @@ int32_t k5_ipc_send_request (const char    *in_service_id,
     if (!err) {
         /* depending on how big the message is, use the fast inline buffer or  
          * the slow dynamically allocated buffer */
-        mach_msg_type_number_t request_length = k5_ipc_stream_size (in_request_stream);
+        mach_msg_type_number_t request_length = krb5int_ipc_stream_size (in_request_stream);
         
         if (request_length > K5_IPC_MAX_INL_MSG_SIZE) {
             /*dprintf ("%s choosing out of line buffer (size is %d)", 
              *                  __FUNCTION__, request_length); */
             
             err = vm_read (mach_task_self (), 
-                           (vm_address_t) k5_ipc_stream_data (in_request_stream), 
+                           (vm_address_t) krb5int_ipc_stream_data (in_request_stream), 
                            request_length, 
                            (vm_address_t *) &ool_request, 
                            &ool_request_length);        
@@ -391,7 +391,7 @@ int32_t k5_ipc_send_request (const char    *in_service_id,
              *                  __FUNCTION__, request_length); */
             
             inl_request_length = request_length;
-            inl_request = k5_ipc_stream_data (in_request_stream);
+            inl_request = krb5int_ipc_stream_data (in_request_stream);
         }
     }
 
@@ -473,7 +473,7 @@ int32_t k5_ipc_send_request (const char    *in_service_id,
     }
     
     if (!err) {
-        err = k5_ipc_stream_new (&cinfo->reply_stream);
+        err = krb5int_ipc_stream_new (&cinfo->reply_stream);
     }
     
     if (!err) {
@@ -519,7 +519,7 @@ int32_t k5_ipc_send_request (const char    *in_service_id,
                        (vm_address_t) ool_request, ool_request_length); 
     }
     if (cinfo && cinfo->reply_stream) { 
-        k5_ipc_stream_release (cinfo->reply_stream); 
+        krb5int_ipc_stream_release (cinfo->reply_stream); 
         cinfo->reply_stream = NULL;
     }
     
diff --git a/src/util/mac/k5_mig_server.c b/src/util/mac/k5_mig_server.c
index 45f1b31..03a7a81 100644
--- a/src/util/mac/k5_mig_server.c
+++ b/src/util/mac/k5_mig_server.c
@@ -136,15 +136,15 @@ kern_return_t k5_ipc_server_request (mach_port_t             in_connection_port,
     k5_ipc_stream request_stream = NULL;
     
     if (!err) {
-        err = k5_ipc_stream_new (&request_stream);
+        err = krb5int_ipc_stream_new (&request_stream);
     }
     
     if (!err) {
         if (in_inl_requestCnt) {
-            err = k5_ipc_stream_write (request_stream, in_inl_request, in_inl_requestCnt);
+            err = krb5int_ipc_stream_write (request_stream, in_inl_request, in_inl_requestCnt);
             
         } else if (in_ool_requestCnt) {
-            err = k5_ipc_stream_write (request_stream, in_ool_request, in_ool_requestCnt);
+            err = krb5int_ipc_stream_write (request_stream, in_ool_request, in_ool_requestCnt);
             
         } else {
             err = EINVAL;
@@ -155,7 +155,7 @@ kern_return_t k5_ipc_server_request (mach_port_t             in_connection_port,
         err = k5_ipc_server_handle_request (in_connection_port, in_reply_port, request_stream);
     }
     
-    k5_ipc_stream_release (request_stream);
+    krb5int_ipc_stream_release (request_stream);
     if (in_ool_requestCnt) { vm_deallocate (mach_task_self (), (vm_address_t) in_ool_request, in_ool_requestCnt); }
     
     return err;
@@ -346,14 +346,14 @@ int32_t k5_ipc_server_send_reply (mach_port_t   in_reply_port,
     if (!err) {
         /* depending on how big the message is, use the fast inline buffer or  
          * the slow dynamically allocated buffer */
-        mach_msg_type_number_t reply_length = k5_ipc_stream_size (in_reply_stream);
+        mach_msg_type_number_t reply_length = krb5int_ipc_stream_size (in_reply_stream);
         
         if (reply_length > K5_IPC_MAX_INL_MSG_SIZE) {            
             //dprintf ("%s choosing out of line buffer (size is %d)", 
             //                  __FUNCTION__, reply_length);
             
             err = vm_read (mach_task_self (), 
-                           (vm_address_t) k5_ipc_stream_data (in_reply_stream), reply_length, 
+                           (vm_address_t) krb5int_ipc_stream_data (in_reply_stream), reply_length, 
                            (vm_address_t *) &ool_reply, &ool_reply_length);
             
         } else {
@@ -361,7 +361,7 @@ int32_t k5_ipc_server_send_reply (mach_port_t   in_reply_port,
             //                  __FUNCTION__, reply_length);
             
             inl_reply_length = reply_length;
-            memcpy (inl_reply, k5_ipc_stream_data (in_reply_stream), reply_length);
+            memcpy (inl_reply, krb5int_ipc_stream_data (in_reply_stream), reply_length);
         }
     }
     
diff --git a/src/util/support/ipc_stream.c b/src/util/support/ipc_stream.c
index 3da2cbc..92d47e6 100644
--- a/src/util/support/ipc_stream.c
+++ b/src/util/support/ipc_stream.c
@@ -52,8 +52,8 @@ static const struct k5_ipc_stream_s k5_ipc_stream_initializer = { NULL, 0, 0 };
 
 /* ------------------------------------------------------------------------ */
 
-static uint32_t k5_ipc_stream_reallocate (k5_ipc_stream io_stream,
-                                          uint64_t      in_new_size)
+static uint32_t krb5int_ipc_stream_reallocate (k5_ipc_stream io_stream,
+					       uint64_t      in_new_size)
 {
     int32_t err = 0;
     uint64_t new_max_size = 0;
@@ -102,7 +102,7 @@ static uint32_t k5_ipc_stream_reallocate (k5_ipc_stream io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-int32_t k5_ipc_stream_new (k5_ipc_stream *out_stream)
+int32_t krb5int_ipc_stream_new (k5_ipc_stream *out_stream)
 {
     int32_t err = 0;
     k5_ipc_stream stream = NULL;
@@ -123,7 +123,7 @@ int32_t k5_ipc_stream_new (k5_ipc_stream *out_stream)
         stream = NULL;
     }
     
-    k5_ipc_stream_release (stream);
+    krb5int_ipc_stream_release (stream);
     
     return k5_check_error (err);    
 }
@@ -131,7 +131,7 @@ int32_t k5_ipc_stream_new (k5_ipc_stream *out_stream)
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_release (k5_ipc_stream io_stream)
+uint32_t krb5int_ipc_stream_release (k5_ipc_stream io_stream)
 {	
     int32_t err = 0;
     
@@ -145,7 +145,7 @@ uint32_t k5_ipc_stream_release (k5_ipc_stream io_stream)
 
 /* ------------------------------------------------------------------------ */
 
-uint64_t k5_ipc_stream_size (k5_ipc_stream in_stream)
+uint64_t krb5int_ipc_stream_size (k5_ipc_stream in_stream)
 {
     return in_stream ? in_stream->size : 0;
 }
@@ -153,7 +153,7 @@ uint64_t k5_ipc_stream_size (k5_ipc_stream in_stream)
 
 /* ------------------------------------------------------------------------ */
 
-const char *k5_ipc_stream_data (k5_ipc_stream in_stream)
+const char *krb5int_ipc_stream_data (k5_ipc_stream in_stream)
 {
     return in_stream ? in_stream->data : NULL;
 }
@@ -164,9 +164,9 @@ const char *k5_ipc_stream_data (k5_ipc_stream in_stream)
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read (k5_ipc_stream  io_stream, 
-                             void         *io_data, 
-                             uint64_t     in_size)
+uint32_t krb5int_ipc_stream_read (k5_ipc_stream  io_stream, 
+				  void         *io_data, 
+				  uint64_t     in_size)
 {
     int32_t err = 0;
     
@@ -184,7 +184,7 @@ uint32_t k5_ipc_stream_read (k5_ipc_stream  io_stream,
         memmove (io_stream->data, &io_stream->data[in_size], 
                  io_stream->size - in_size);
         
-        err = k5_ipc_stream_reallocate (io_stream, io_stream->size - in_size);
+        err = krb5int_ipc_stream_reallocate (io_stream, io_stream->size - in_size);
         
         if (!err) {
             io_stream->size -= in_size;
@@ -196,9 +196,9 @@ uint32_t k5_ipc_stream_read (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write (k5_ipc_stream  io_stream,
-                              const void   *in_data, 
-                              uint64_t     in_size)
+uint32_t krb5int_ipc_stream_write (k5_ipc_stream  io_stream,
+				   const void   *in_data, 
+				   uint64_t     in_size)
 {
     int32_t err = 0;
     
@@ -213,7 +213,7 @@ uint32_t k5_ipc_stream_write (k5_ipc_stream  io_stream,
     }
     
     if (!err) {
-        err = k5_ipc_stream_reallocate (io_stream, io_stream->size + in_size);
+        err = krb5int_ipc_stream_reallocate (io_stream, io_stream->size + in_size);
     }
     
     if (!err) {
@@ -230,15 +230,15 @@ uint32_t k5_ipc_stream_write (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-void k5_ipc_stream_free_string (char *in_string)
+void krb5int_ipc_stream_free_string (char *in_string)
 {
     free (in_string);
 }
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read_string (k5_ipc_stream   io_stream, 
-                                    char         **out_string)
+uint32_t krb5int_ipc_stream_read_string (k5_ipc_stream   io_stream, 
+					 char         **out_string)
 {
     int32_t err = 0;
     uint32_t length = 0;
@@ -248,7 +248,7 @@ uint32_t k5_ipc_stream_read_string (k5_ipc_stream   io_stream,
     if (!out_string) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_read_uint32 (io_stream, &length);
+        err = krb5int_ipc_stream_read_uint32 (io_stream, &length);
     }
     
     if (!err) {
@@ -257,7 +257,7 @@ uint32_t k5_ipc_stream_read_string (k5_ipc_stream   io_stream,
     }
     
     if (!err) {
-        err = k5_ipc_stream_read (io_stream, string, length);
+        err = krb5int_ipc_stream_read (io_stream, string, length);
     }
     
     if (!err) {
@@ -272,8 +272,8 @@ uint32_t k5_ipc_stream_read_string (k5_ipc_stream   io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write_string (k5_ipc_stream  io_stream, 
-                                     const char    *in_string)
+uint32_t krb5int_ipc_stream_write_string (k5_ipc_stream  io_stream, 
+					  const char    *in_string)
 {
     int32_t err = 0;
     uint32_t length = 0;
@@ -284,11 +284,11 @@ uint32_t k5_ipc_stream_write_string (k5_ipc_stream  io_stream,
     if (!err) {
         length = strlen (in_string) + 1;
         
-        err = k5_ipc_stream_write_uint32 (io_stream, length);
+        err = krb5int_ipc_stream_write_uint32 (io_stream, length);
     }
     
     if (!err) {
-        err = k5_ipc_stream_write (io_stream, in_string, length);
+        err = krb5int_ipc_stream_write (io_stream, in_string, length);
     }
     
     return k5_check_error (err);
@@ -300,8 +300,8 @@ uint32_t k5_ipc_stream_write_string (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read_int32 (k5_ipc_stream  io_stream, 
-                                   int32_t       *out_int32)
+uint32_t krb5int_ipc_stream_read_int32 (k5_ipc_stream  io_stream, 
+					int32_t       *out_int32)
 {
     int32_t err = 0;
     int32_t int32 = 0;
@@ -310,7 +310,7 @@ uint32_t k5_ipc_stream_read_int32 (k5_ipc_stream  io_stream,
     if (!out_int32) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_read (io_stream, &int32, sizeof (int32));
+        err = krb5int_ipc_stream_read (io_stream, &int32, sizeof (int32));
     }
     
     if (!err) {
@@ -322,8 +322,8 @@ uint32_t k5_ipc_stream_read_int32 (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write_int32 (k5_ipc_stream io_stream, 
-                                    int32_t       in_int32)
+uint32_t krb5int_ipc_stream_write_int32 (k5_ipc_stream io_stream, 
+					 int32_t       in_int32)
 {
     int32_t err = 0;
     int32_t int32 = htonl (in_int32);
@@ -331,7 +331,7 @@ uint32_t k5_ipc_stream_write_int32 (k5_ipc_stream io_stream,
     if (!io_stream) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_write (io_stream, &int32, sizeof (int32));
+        err = krb5int_ipc_stream_write (io_stream, &int32, sizeof (int32));
     }
     
     return k5_check_error (err);
@@ -343,8 +343,8 @@ uint32_t k5_ipc_stream_write_int32 (k5_ipc_stream io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read_uint32 (k5_ipc_stream  io_stream, 
-                                    uint32_t      *out_uint32)
+uint32_t krb5int_ipc_stream_read_uint32 (k5_ipc_stream  io_stream, 
+					 uint32_t      *out_uint32)
 {
     int32_t err = 0;
     uint32_t uint32 = 0;
@@ -353,7 +353,7 @@ uint32_t k5_ipc_stream_read_uint32 (k5_ipc_stream  io_stream,
     if (!out_uint32) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_read (io_stream, &uint32, sizeof (uint32));
+        err = krb5int_ipc_stream_read (io_stream, &uint32, sizeof (uint32));
     }
     
     if (!err) {
@@ -365,8 +365,8 @@ uint32_t k5_ipc_stream_read_uint32 (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write_uint32 (k5_ipc_stream io_stream, 
-                                     uint32_t      in_uint32)
+uint32_t krb5int_ipc_stream_write_uint32 (k5_ipc_stream io_stream, 
+					  uint32_t      in_uint32)
 {
     int32_t err = 0;
     int32_t uint32 = htonl (in_uint32);
@@ -374,7 +374,7 @@ uint32_t k5_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
     if (!io_stream) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_write (io_stream, &uint32, sizeof (uint32));
+        err = krb5int_ipc_stream_write (io_stream, &uint32, sizeof (uint32));
     }
     
     return k5_check_error (err);
@@ -386,8 +386,8 @@ uint32_t k5_ipc_stream_write_uint32 (k5_ipc_stream io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read_int64 (k5_ipc_stream  io_stream, 
-                                   int64_t       *out_int64)
+uint32_t krb5int_ipc_stream_read_int64 (k5_ipc_stream  io_stream, 
+					int64_t       *out_int64)
 {
     int32_t err = 0;
     uint64_t int64 = 0;
@@ -396,7 +396,7 @@ uint32_t k5_ipc_stream_read_int64 (k5_ipc_stream  io_stream,
     if (!out_int64) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_read (io_stream, &int64, sizeof (int64));
+        err = krb5int_ipc_stream_read (io_stream, &int64, sizeof (int64));
     }
     
     if (!err) {
@@ -408,8 +408,8 @@ uint32_t k5_ipc_stream_read_int64 (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write_int64 (k5_ipc_stream io_stream, 
-                                    int64_t     in_int64)
+uint32_t krb5int_ipc_stream_write_int64 (k5_ipc_stream io_stream, 
+					 int64_t     in_int64)
 {
     int32_t err = 0;
     int64_t int64 = htonll (in_int64);
@@ -417,7 +417,7 @@ uint32_t k5_ipc_stream_write_int64 (k5_ipc_stream io_stream,
     if (!io_stream) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_write (io_stream, &int64, sizeof (int64));
+        err = krb5int_ipc_stream_write (io_stream, &int64, sizeof (int64));
     }
     
     return k5_check_error (err);
@@ -430,8 +430,8 @@ uint32_t k5_ipc_stream_write_int64 (k5_ipc_stream io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_read_uint64 (k5_ipc_stream  io_stream, 
-                                    uint64_t     *out_uint64)
+uint32_t krb5int_ipc_stream_read_uint64 (k5_ipc_stream  io_stream, 
+					 uint64_t     *out_uint64)
 {
     int32_t err = 0;
     uint64_t uint64 = 0;
@@ -440,7 +440,7 @@ uint32_t k5_ipc_stream_read_uint64 (k5_ipc_stream  io_stream,
     if (!out_uint64) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_read (io_stream, &uint64, sizeof (uint64));
+        err = krb5int_ipc_stream_read (io_stream, &uint64, sizeof (uint64));
     }
     
     if (!err) {
@@ -452,8 +452,8 @@ uint32_t k5_ipc_stream_read_uint64 (k5_ipc_stream  io_stream,
 
 /* ------------------------------------------------------------------------ */
 
-uint32_t k5_ipc_stream_write_uint64 (k5_ipc_stream io_stream, 
-                                     uint64_t      in_uint64)
+uint32_t krb5int_ipc_stream_write_uint64 (k5_ipc_stream io_stream, 
+					  uint64_t      in_uint64)
 {
     int32_t err = 0;
     int64_t uint64 = htonll (in_uint64);
@@ -461,7 +461,7 @@ uint32_t k5_ipc_stream_write_uint64 (k5_ipc_stream io_stream,
     if (!io_stream) { err = k5_check_error (EINVAL); }
     
     if (!err) {
-        err = k5_ipc_stream_write (io_stream, &uint64, sizeof (uint64));
+        err = krb5int_ipc_stream_write (io_stream, &uint64, sizeof (uint64));
     }
     
     return k5_check_error (err);