r18022@luminous: jaltman | 2006-05-19 05:18:37 -0400

 Updates of portable CCAPI sources.   All code compiles.
 
 
 r18025@luminous:  jaltman | 2006-05-20 23:48:39 -0400
 Construct an outline of a sample platform specific main.c
 
 Add ccs_serv_cleanup() routine.  Currently does nothing.
 
 Correct field names used within the authorization check.
 
 
 r18026@luminous:  jaltman | 2006-05-22 02:25:43 -0400
 More byte order conversions in the server operations code.
 
 
 
 r18027@luminous:  jaltman | 2006-05-22 13:12:49 -0400
 Source files containing common routines used by both 
 the client and the server.
 
 
 
 r18028@luminous:  jaltman | 2006-05-22 13:17:07 -0400
 Move msg.c and marshall.c to common library.
 
 Add dllmain.c which contains the Windows DllMain() entry 
 point.  This must be moved later to a Windows specific 
 directory.
 
 Cleanup type usage and function name references.  
 
 All that is missing now from the client DLL is a definition
 of cci_perform_rpc() which is the entry point to the IPC
 routine.
 
 
 r18029@luminous:  jaltman | 2006-05-22 13:18:27 -0400
 Move generic list functions to common/generic_lists.c
 so they can be used by both the client dll and the server.
 
 Fix type utilization in serv_ops.c
 
 
 r18083@luminous:  jaltman | 2006-06-05 13:49:34 -0400
 improved error handling
 
 
 r18094@luminous:  jaltman | 2006-06-09 10:42:04 -0400
 * corrections to windows rpc layer
 
 * corrections to network byte order conversions
 
 
 r18095@luminous:  lxs | 2006-06-09 17:46:24 -0400
 cci_msg_retrieve_blob(): changed argument 4 from void** to char** 
 to suppress the warnings from gcc.
 
 r18096@luminous:  lxs | 2006-06-09 17:55:32 -0400
 moved enum cc_list_type to generic_lists.h to avoid "incomplete enum" 
 warnings when compiling generic_lists.c
 
 r18097@luminous:  lxs | 2006-06-09 17:56:15 -0400
 Removed ancient Metrowerks tests from public headers.
 
 r18098@luminous:  lxs | 2006-06-09 17:57:20 -0400
 Include string.h to get memcpy, strlen, etc on BSD OSes.
 
 r18099@luminous:  lxs | 2006-06-09 17:59:36 -0400
 Added Mac OS X project file and Mach-IPC support code
 
 
 r18106@luminous:  jaltman | 2006-06-12 09:56:31 -0400
 remove duplicate header file and obsolete source file
 
 
 r18193@luminous:  jaltman | 2006-06-22 12:57:14 -0400
 This commit updates lib/krb5/ccache/ccapi to support CCAPI Version 3
 and above.  Specify -DUSE_CCAPI_V3=1 when compiling to use CCAPI Version 3
 
 
 r18194@luminous:  jaltman | 2006-06-22 12:58:37 -0400
 Fix parameter name in cc_credentials_iterator_t next()
 
 
 r18195@luminous:  jaltman | 2006-06-22 12:59:08 -0400
 Add missing header
 
 
 r18196@luminous:  jaltman | 2006-06-22 13:11:37 -0400
 Use the old exported names for setup and shutdown
 
 
 r18197@luminous:  jaltman | 2006-06-22 13:18:14 -0400
 krb5_stdccv3_setup is ok
 
 

=== Please enter your commit message above this line ===

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

15 files changed, 1638 insertions, 773 deletions

diff --git a/src/lib/ccapi/client/NTMakefile b/src/lib/ccapi/client/NTMakefile
index 09ef9df38b..2ce87c3507 100644
--- a/src/lib/ccapi/client/NTMakefile
+++ b/src/lib/ccapi/client/NTMakefile
@@ -1,22 +1,18 @@
 !INCLUDE <WIN32.MAK>
 
-CFLAGS = -I../include
+CFLAGS = -I../include $(cdebug) $(cflags) $(cvarsmt)
 
-CCAPI_OBJS = cacheapi.obj context.obj ccache.obj credentials.obj ccache_iterator.obj \
-             credentials_iterator.obj ccstring.obj marshall.obj msg.obj 
+CC_CLIENT_OBJS = cacheapi.obj context.obj ccache.obj credentials.obj ccache_iterator.obj \
+             credentials_iterator.obj ccstring.obj ccapiv2.obj
 
-CCAPI_LIB = ccapi.lib
-
-$(CCAPI_LIB): $(CCAPI_OBJS)
-        $(implib) /NOLOGO /OUT:$@ $**
-
-CCAPI_DLLFILE = krbcc32.dll
+CC_CLIENT_LIB = cc_client.lib
 
+CC_COMMON_LIB = ..\common\cc_common.lib
 
+$(CC_CLIENT_LIB): $(CC_CLIENT_OBJS)
+        $(implib) /NOLOGO /OUT:$@ $**
 
-$(CCAPI_DLLFILE): $(CCAPI_LIB)
-        $(DLLGUILINK) -def:windows\krbcc32.def
-        $(DLLPREP)
+all: $(CC_CLIENT_LIB)
 
 clean:
         del *.obj *.lib
diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c
index 2c874bec0f..89c5e63d1b 100644
--- a/src/lib/ccapi/client/cacheapi.c
+++ b/src/lib/ccapi/client/cacheapi.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -43,33 +43,43 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <CredentialsCache.h>
 #include "ccache.h"
 #include "ccache_iterator.h"
 #include "context.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
 
-cc_int32 
+/*! \fn cc_initialize
+ *  \brief A function that initializes a ccapi context for the caller.
+ *  \param[out] outContext a cc_context_t pointer to which is assigned the newly created context upon success.
+ *  \param[in]  inVersion  a cc_int32 that specifies the 
+ */
+
+CCACHE_API cc_int32 
 cc_initialize (	cc_context_t*		outContext,
                 cc_int32		inVersion,
                 cc_int32*		outSupportedVersion,
                 char const**		outVendor)
 {
     static char vendor[128] = "";
-    cc_msg_t     *request;
+    cc_msg_t     *request = NULL;
     ccmsg_init_t *request_header;
-    cc_msg_t     *response;
+    cc_msg_t     *response = NULL;
+    cc_uint32 type;
     ccmsg_init_resp_t *response_header;
     cc_int32 code;
 
     if ((inVersion != ccapi_version_2) &&
          (inVersion != ccapi_version_3) &&
          (inVersion != ccapi_version_4) &&
-         (inVersion != ccapi_version_5)) {
+         (inVersion != ccapi_version_5) &&
+	 (inVersion != ccapi_version_6)) {
 
         if (outSupportedVersion != NULL) {
-            *outSupportedVersion = ccapi_version_5;
+            *outSupportedVersion = ccapi_version_6;
         }
         return ccErrBadAPIVersion;
     }   
@@ -78,29 +88,43 @@ cc_initialize (	cc_context_t*		outContext,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    request_header->in_version = inVersion;
+    /* If the version number is 2, the caller will be passing
+     * the structure into the v2 compatibility functions which
+     * in turn will call the v6 functions.  Set the version to
+     * ccapi_version_max since that is what the compatibility 
+     * functions will be expecting.
+     */
+    if (inVersion == ccapi_version_2)
+	inVersion = ccapi_version_max;
+
+    /* Construct the request */
+    request_header->in_version = htonl(inVersion);
 
     code = cci_msg_new(ccmsg_INIT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+		goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_init_t));
+	if (code != ccNoError) 
+		goto cleanup;
+	request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+	if (code != ccNoError)
+		goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_init_resp_t *)response->header;
-        *outSupportedVersion = response_header->out_version;
-        code = cc_context_int_new(outContext, response_header->out_ctx, response_header->out_version);
+        *outSupportedVersion = ntohl(response_header->out_version);
+        code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version));
 
         if (!vendor[0]) {
             char * string;
-            code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string);
+            code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string);
             strncpy(vendor, string, sizeof(vendor)-1);
             vendor[sizeof(vendor)-1] = '\0';
             free(string);
@@ -111,8 +135,15 @@ cc_initialize (	cc_context_t*		outContext,
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c
index 5de3880e4f..07e9b8e879 100644
--- a/src/lib/ccapi/client/ccache.c
+++ b/src/lib/ccapi/client/ccache.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -46,11 +46,21 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <CredentialsCache.h>
 #include "credentials.h"
+#include "credentials_iterator.h"
 #include "ccache.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
+#include "ccstring.h"
+
+/* 
+ * cc_int_ccache_new
+ *
+ * Input parameters in host order.
+ */
 
 cc_int32
 cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache )
@@ -97,11 +107,12 @@ cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache )
 cc_int32    
 cc_int_ccache_release( cc_ccache_t ccache )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_release_t 	*request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -114,30 +125,41 @@ cc_int_ccache_release( cc_ccache_t ccache )
     request_header = (ccmsg_ccache_release_t*)malloc(sizeof(ccmsg_ccache_release_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_RELEASE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+        goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_release_t));
+    if (code != ccNoError)
+        goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+        goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
-    free(int_ccache->functions);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
+    if (int_ccache->functions)
+	free(int_ccache->functions);
     free(int_ccache);
     return code;
 }
@@ -146,11 +168,12 @@ cc_int_ccache_release( cc_ccache_t ccache )
 cc_int32    
 cc_int_ccache_destroy( cc_ccache_t ccache )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_destroy_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_destroy_t 	*request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -163,29 +186,39 @@ cc_int_ccache_destroy( cc_ccache_t ccache )
     request_header = (ccmsg_ccache_destroy_t*)malloc(sizeof(ccmsg_ccache_destroy_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_DESTROY, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_destroy_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     free(ccache);
     return code;
 }
@@ -194,11 +227,12 @@ cc_int_ccache_destroy( cc_ccache_t ccache )
 cc_int32
 cc_int_ccache_set_default( cc_ccache_t ccache )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_set_default_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 			int_ccache;
+    cc_msg_t        			*request = NULL;
+    ccmsg_ccache_set_default_t 		*request_header = NULL;
+    cc_msg_t        			*response = NULL;
+    cc_uint32				type;
+    cc_int32 				code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -211,29 +245,39 @@ cc_int_ccache_set_default( cc_ccache_t ccache )
     request_header = (ccmsg_ccache_set_default_t*)malloc(sizeof(ccmsg_ccache_set_default_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_SET_DEFAULT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_default_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -241,11 +285,12 @@ cc_int32
 cc_int_ccache_get_credentials_version( cc_ccache_t ccache,
                                    cc_uint32* credentials_version)
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_creds_version_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_get_creds_version_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -258,43 +303,53 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_creds_version_t*)malloc(sizeof(ccmsg_ccache_get_creds_version_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_CREDS_VERSION, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_creds_version_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_get_creds_version_resp_t * response_header = (ccmsg_ccache_get_creds_version_resp_t*)response->header;
-        *credentials_version = response_header->version;
+        *credentials_version = ntohl(response_header->version);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
-cc_int_ccache_get_name( cc_ccache_t ccache,
-                    cc_string_t* name )
+cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_name_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_get_name_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -307,36 +362,46 @@ cc_int_ccache_get_name( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_name_t*)malloc(sizeof(ccmsg_ccache_get_name_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_NAME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_name_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         char * string;
         ccmsg_ccache_get_name_resp_t * response_header = (ccmsg_ccache_get_name_resp_t*)response->header;
         code = cci_msg_retrieve_blob(response, response_header->name_offset, 
                                       response_header->name_len, &string);
         if (code == ccNoError) {
-            code = cc_string_new(&name, string);
+            code = cci_string_new(name, string);
             free(string);
         }
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -345,11 +410,12 @@ cc_int_ccache_get_principal( cc_ccache_t ccache,
                         cc_uint32 credentials_version,
                         cc_string_t* principal )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_principal_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_get_principal_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -362,37 +428,47 @@ cc_int_ccache_get_principal( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_principal_t*)malloc(sizeof(ccmsg_ccache_get_principal_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->version = credentials_version;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->version = htonl(credentials_version);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_principal_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         char * string;
         ccmsg_ccache_get_principal_resp_t * response_header = (ccmsg_ccache_get_principal_resp_t*)response->header;
         code = cci_msg_retrieve_blob(response, response_header->principal_offset, 
                                       response_header->principal_len, &string);
         if (code == ccNoError) {
-            code = cc_string_new(&principal, string);
+            code = cci_string_new(principal, string);
             free(string);
         }
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -401,12 +477,13 @@ cc_int_ccache_set_principal( cc_ccache_t ccache,
                          cc_uint32 credentials_version,
                          const char* principal )
 {
-    cc_uint32   blob_pos;
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_set_principal_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_uint32   	blob_pos;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_set_principal_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -419,40 +496,47 @@ cc_int_ccache_set_principal( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_set_principal_t*)malloc(sizeof(ccmsg_ccache_set_principal_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->version = credentials_version;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->version = htonl(credentials_version);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void*)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_principal_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -460,11 +544,12 @@ cc_int32
 cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache,
                                         cc_credentials_iterator_t* iterator )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_creds_iterator_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_creds_iterator_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -477,30 +562,41 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_creds_iterator_t*)malloc(sizeof(ccmsg_ccache_creds_iterator_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
-    code = cci_msg_new(ccmsg_CCACHE_CREDS_ITERATOR, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CCACHE_NEW_CREDS_ITERATOR, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_creds_iterator_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_creds_iterator_resp_t * response_header = (ccmsg_ccache_creds_iterator_resp_t*)response->header;
-        code = cc_int_credentials_iterator_new(iterator, response_header->iterator);
+        code = cc_int_credentials_iterator_new(iterator, int_ccache->ctx, int_ccache->handle,
+						ntohll(response_header->iterator));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -508,14 +604,15 @@ cc_int32
 cc_int_ccache_store_credentials( cc_ccache_t ccache,
                              const cc_credentials_union* credentials )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_store_creds_t *request_header;
-    cc_msg_t        *response;
-    char            *flat_cred = 0;
-    cc_uint32       flat_cred_len = 0;
-    cc_uint32       blob_pos;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_store_creds_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    char            	*flat_cred = 0;
+    cc_uint32       	flat_cred_len = 0;
+    cc_uint32       	blob_pos;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL || credentials == NULL )
         return ccErrBadParam;
@@ -528,14 +625,12 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_store_creds_t*)malloc(sizeof(ccmsg_ccache_store_creds_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_STORE_CREDS, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     switch ( credentials->version ) {
     case cc_credentials_v4:
@@ -545,42 +640,47 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache,
         code = cci_creds_v5_marshall(credentials->credentials.credentials_v5, &flat_cred, &flat_cred_len);
         break;
     default:
-        cci_msg_destroy(request);
-        free(request_header);
-        return ccErrBadCredentialsVersion;
-    }
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
+        code = ccErrBadCredentialsVersion;
     }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void*)flat_cred, flat_cred_len, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->creds_version = credentials->version;
-    request_header->creds_offset = blob_pos;
-    request_header->creds_len = flat_cred_len;
+    request_header->creds_version = htonl(credentials->version);
+    request_header->creds_offset = htonl(blob_pos);
+    request_header->creds_len = htonl(flat_cred_len);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_store_creds_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    free(flat_cred);
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (flat_cred)
+	free(flat_cred);
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -588,12 +688,13 @@ cc_int32
 cc_int_ccache_remove_credentials( cc_ccache_t ccache,
                               cc_credentials_t credentials )
 {
-    cc_int_ccache_t int_ccache;
-    cc_int_credentials_t  int_creds;
-    cc_msg_t        *request;
-    ccmsg_ccache_rem_creds_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_int_credentials_t  	int_creds;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_rem_creds_t 	*request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL || credentials == NULL )
         return ccErrBadParam;
@@ -611,30 +712,40 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache,
     if (request_header == NULL)
         return ccErrNoMem;
     
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->creds  = int_creds->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->creds  = htonll(int_creds->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_REM_CREDS, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_rem_creds_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -643,12 +754,13 @@ cc_int32
 cc_int_ccache_move( cc_ccache_t source,
                     cc_ccache_t destination )
 {
-    cc_int_ccache_t int_ccache_source;
-    cc_int_ccache_t int_ccache_dest;
-    cc_msg_t        *request;
-    ccmsg_ccache_move_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache_source;
+    cc_int_ccache_t 	int_ccache_dest;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_move_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( source == NULL || destination == NULL )
         return ccErrBadParam;
@@ -668,29 +780,39 @@ cc_int_ccache_move( cc_ccache_t source,
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CCACHE_MOVE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_ccache_source->ctx;
-    request_header->ccache_source = int_ccache_source->handle;
-    request_header->ccache_dest = int_ccache_dest->handle;
+    request_header->ctx = htonll(int_ccache_source->ctx);
+    request_header->ccache_source = htonll(int_ccache_source->handle);
+    request_header->ccache_dest = htonll(int_ccache_dest->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_move_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }       
 
@@ -698,14 +820,16 @@ cc_int_ccache_lock( cc_ccache_t ccache,
                 cc_uint32 lock_type,
                 cc_uint32 block )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_lock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_lock_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL || 
-         (lock_type != cc_lock_read && lock_type != cc_lock_write) ||
+         (lock_type != cc_lock_read && lock_type != cc_lock_write &&
+	  lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) ||
          (block != cc_lock_block && block != cc_lock_noblock) )
         return ccErrBadParam;
 
@@ -719,22 +843,26 @@ cc_int_ccache_lock( cc_ccache_t ccache,
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CCACHE_LOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->lock_type;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->lock_type = htonl(lock_type);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_lock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
 
         // TODO: if (block == cc_lock_block) .....
     } else if (response->type == ccmsg_ACK) {
@@ -742,19 +870,26 @@ cc_int_ccache_lock( cc_ccache_t ccache,
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
 cc_int_ccache_unlock( cc_ccache_t ccache )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_unlock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_unlock_t 	*request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -769,41 +904,53 @@ cc_int_ccache_unlock( cc_ccache_t ccache )
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CCACHE_UNLOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_unlock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = htonl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = htonl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 
 cc_int32
 cc_int_ccache_get_last_default_time( cc_ccache_t ccache,
-                                     cc_time_t* time_offset )
+                                     cc_time* time_offset )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_last_default_time_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_get_last_default_time_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_time64			t64;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -816,43 +963,56 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_last_default_time_t*)malloc(sizeof(ccmsg_ccache_get_last_default_time_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_LAST_DEFAULT_TIME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_last_default_time_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_get_last_default_time_resp_t * response_header = (ccmsg_ccache_get_last_default_time_resp_t*)response->header;
-        *time_offset = response_header->last_default_time;
-        code = ccNoError;
+        t64 = ntohll(response_header->last_default_time);
+	/* TODO: validate that we do not overflow the max value of time_offset */
+        *time_offset = t64;
+	code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
-cc_int_ccache_get_change_time( cc_ccache_t ccache,
-                           cc_time_t* time )
+cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_change_time_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_get_change_time_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_time64		t64;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -865,31 +1025,43 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_change_time_t*)malloc(sizeof(ccmsg_ccache_get_change_time_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_CHANGE_TIME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_change_time_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_get_change_time_resp_t * response_header = (ccmsg_ccache_get_change_time_resp_t*)response->header;
-        *time = response_header->time;
+        t64 = htonll(response_header->time);
+	/* TODO: validate that we do not overflow 'time' */
+	*time = t64;
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -898,12 +1070,13 @@ cc_int_ccache_compare( cc_ccache_t ccache,
                    cc_ccache_t compare_to,
                    cc_uint32* equal )
 {
-    cc_int_ccache_t int_ccache;
-    cc_int_ccache_t int_compare_to;
-    cc_msg_t        *request;
-    ccmsg_ccache_compare_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_int_ccache_t 		int_compare_to;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_compare_t 	*request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -918,45 +1091,56 @@ cc_int_ccache_compare( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_compare_t*)malloc(sizeof(ccmsg_ccache_compare_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache1 = int_ccache->handle;
-    request_header->ccache2 = int_compare_to->handle;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache1 = htonll(int_ccache->handle);
+    request_header->ccache2 = htonll(int_compare_to->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_COMPARE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_compare_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_compare_resp_t * response_header = (ccmsg_ccache_compare_resp_t*)response->header;
-        *equal = response_header->is_equal;
+        *equal = ntohl(response_header->is_equal);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32	
 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache,
                                cc_int32	credentials_version,
-                               cc_time_t*	time_offset )
+                               cc_time*	time_offset )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_get_kdc_time_offset_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 		int_ccache;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_get_kdc_time_offset_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -969,45 +1153,57 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_get_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_get_kdc_time_offset_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->creds_version = credentials_version;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->creds_version = htonl(credentials_version);
 
     code = cci_msg_new(ccmsg_CCACHE_GET_KDC_TIME_OFFSET, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_kdc_time_offset_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
     } else if (response->type == ccmsg_ACK) {
         ccmsg_ccache_get_kdc_time_offset_resp_t * response_header = (ccmsg_ccache_get_kdc_time_offset_resp_t*)response->header;
-        *time_offset = response_header->offset;
+        *time_offset = (cc_time64)ntohll(response_header->offset);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache,
                                cc_int32	credentials_version,
-                               cc_time_t	time_offset )
+                               cc_time	time_offset )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_set_kdc_time_offset_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_set_kdc_time_offset_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_int64		t64;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -1020,30 +1216,42 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache,
     request_header = (ccmsg_ccache_set_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_set_kdc_time_offset_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->creds_version = credentials_version;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->creds_version = htonl(credentials_version);
+    t64 = time_offset;
+    request_header->offset = htonll(t64);
 
     code = cci_msg_new(ccmsg_CCACHE_SET_KDC_TIME_OFFSET, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_kdc_time_offset_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
                                 
@@ -1051,11 +1259,12 @@ cc_int32
 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t	ccache,
                                  cc_int32	credentials_version )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
-    ccmsg_ccache_clear_kdc_time_offset_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_clear_kdc_time_offset_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -1068,31 +1277,39 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t	ccache,
     request_header = (ccmsg_ccache_clear_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_clear_kdc_time_offset_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_ccache->ctx;
-    request_header->ccache = int_ccache->handle;
-    request_header->creds_version = credentials_version;
+    request_header->ctx = htonll(int_ccache->ctx);
+    request_header->ccache = htonll(int_ccache->handle);
+    request_header->creds_version = htonl(credentials_version);
 
     code = cci_msg_new(ccmsg_CCACHE_CLEAR_KDC_TIME_OFFSET, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_clear_kdc_time_offset_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
-
-
diff --git a/src/lib/ccapi/client/ccache.h b/src/lib/ccapi/client/ccache.h
index e3b3993ee0..0a92ebf63d 100644
--- a/src/lib/ccapi/client/ccache.h
+++ b/src/lib/ccapi/client/ccache.h
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -114,11 +114,11 @@ cc_int_ccache_unlock( cc_ccache_t ccache );
 
 cc_int32
 cc_int_ccache_get_last_default_time( cc_ccache_t ccache,
-                                cc_time_t* time );
+                                cc_time* time );
 
 cc_int32
 cc_int_ccache_get_change_time( cc_ccache_t ccache,
-                          cc_time_t* time );
+                          cc_time* time );
 
 cc_int32
 cc_int_ccache_compare( cc_ccache_t ccache,
@@ -128,12 +128,12 @@ cc_int_ccache_compare( cc_ccache_t ccache,
 cc_int32	
 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache,
                               cc_int32	credentials_version,
-                              cc_time_t*	time_offset );
+                              cc_time*	time_offset );
 
 cc_int32
 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache,
                               cc_int32	credentials_version,
-                              cc_time_t	time_offset );
+                              cc_time	time_offset );
                                 
 cc_int32
 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t	ccache,
diff --git a/src/lib/ccapi/client/ccache_iterator.c b/src/lib/ccapi/client/ccache_iterator.c
index 03266b1bbe..3da9b35478 100644
--- a/src/lib/ccapi/client/ccache_iterator.c
+++ b/src/lib/ccapi/client/ccache_iterator.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -46,7 +46,9 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <CredentialsCache.h>
+#include "ccache.h"
 #include "ccache_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
 
@@ -56,7 +58,7 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter,
                             cc_handle ctx,
                             cc_handle handle )
 {
-    cc_int_ccache_iterator_t iter;
+    cc_int_ccache_iterator_t iter = NULL;
 
     if ( piter == NULL )
         return ccErrBadParam;
@@ -66,7 +68,7 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter,
         return ccErrNoMem;
 
     iter->functions = (cc_ccache_iterator_f*)malloc( sizeof(cc_ccache_iterator_f));
-    if ( iter->functions ) {
+    if ( iter->functions == NULL ) {
         free(iter);
         return ccErrNoMem;
     }
@@ -84,11 +86,12 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter,
 cc_int32
 cc_int_ccache_iterator_release( cc_ccache_iterator_t iter )
 {
-    cc_int_ccache_iterator_t int_iter;
-    cc_msg_t        *request;
-    ccmsg_ccache_iterator_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_iterator_t 	int_iter;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_iterator_release_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
 
     if ( iter == NULL )
@@ -102,31 +105,43 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter )
     request_header = (ccmsg_ccache_iterator_release_t*)malloc(sizeof(ccmsg_ccache_iterator_release_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_iter->ctx;
-    request_header->iterator = int_iter->handle;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->iterator = htonll(int_iter->handle);
     code = cci_msg_new(ccmsg_CCACHE_ITERATOR_RELEASE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_release_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
 
-    free(int_iter->functions);
-    free(int_iter);
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
+
+    if (int_iter->functions)
+	free(int_iter->functions);
+    if (iter)
+	free(int_iter);
     return ccNoError;
 }
 
@@ -134,11 +149,12 @@ cc_int32
 cc_int_ccache_iterator_next( cc_ccache_iterator_t iter,
                              cc_ccache_t * ccache )
 {
-    cc_int_ccache_iterator_t int_iter;
-    cc_msg_t        *request;
-    ccmsg_ccache_iterator_next_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_ccache_iterator_t 	int_iter;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_iterator_next_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -151,29 +167,98 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter,
     request_header = (ccmsg_ccache_iterator_next_t*)malloc(sizeof(ccmsg_ccache_iterator_next_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_iter->ctx;
-    request_header->iterator = int_iter->handle;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->iterator = htonll(int_iter->handle);
 
     code = cci_msg_new(ccmsg_CCACHE_ITERATOR_NEXT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_next_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
         code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+    } else if (type == ccmsg_ACK) {
         ccmsg_ccache_iterator_next_resp_t * response_header = (ccmsg_ccache_iterator_next_resp_t*)response->header;
-        code = cc_ccache_new(ccache, int_iter->ctx, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_iter->ctx, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
+    return code;
+}
+
+cc_int32
+cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter,
+                              cc_ccache_iterator_t * new_iter )
+{
+    cc_int_ccache_iterator_t 	int_iter;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ccache_iterator_clone_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
+
+    if ( iter == NULL || new_iter == NULL )
+        return ccErrBadParam;
+
+    int_iter = (cc_int_ccache_iterator_t)iter;
+
+    if ( int_iter->magic != CC_CCACHE_ITER_MAGIC )
+        return ccErrInvalidCCacheIterator;
+
+    request_header = (ccmsg_ccache_iterator_clone_t*)malloc(sizeof(ccmsg_ccache_iterator_clone_t));
+    if (request_header == NULL)
+        return ccErrNoMem;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->iterator = htonll(int_iter->handle);
+
+    code = cci_msg_new(ccmsg_CCACHE_ITERATOR_CLONE, &request);
+    if (code != ccNoError)
+	goto cleanup;
+
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_clone_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
+
+    code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
+
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
+        ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
+        ccmsg_ccache_iterator_clone_resp_t * response_header = (ccmsg_ccache_iterator_clone_resp_t*)response->header;
+        code = cc_int_ccache_iterator_new(new_iter, int_iter->ctx, ntohll(response_header->iterator));
+    } else {
+        code = ccErrBadInternalMessage;
+    }
+
+  cleanup:
+    if (request_header)
+	free(request);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
diff --git a/src/lib/ccapi/client/ccache_iterator.h b/src/lib/ccapi/client/ccache_iterator.h
index c55d72ee67..5a390b82ed 100644
--- a/src/lib/ccapi/client/ccache_iterator.h
+++ b/src/lib/ccapi/client/ccache_iterator.h
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -74,6 +74,10 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter,
                              cc_ccache_t * ccache );
 
 cc_int32
+cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter,
+                              cc_ccache_iterator_t * iter_new );
+
+cc_int32
 cc_int_ccache_iterator_set_repeat_count( cc_int_ccache_iterator_t iter, 
                                          cc_uint32 count );
 
diff --git a/src/lib/ccapi/client/ccapiv2.c b/src/lib/ccapi/client/ccapiv2.c
new file mode 100644
index 0000000000..82b04c2c8e
--- /dev/null
+++ b/src/lib/ccapi/client/ccapiv2.c
@@ -0,0 +1,295 @@
+/* $Copyright:

+ *

+ * Copyright 1998-2006 by the Massachusetts Institute of Technology.

+ * 

+ * All rights reserved.

+ * 

+ * Export of this software from the United States of America may require a

+ * specific license from the United States Government.  It is the

+ * responsibility of any person or organization contemplating export to

+ * obtain such a license before exporting.

+ * 

+ * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute

+ * this software and its documentation for any purpose and without fee is

+ * hereby granted, provided that the above copyright notice appear in all

+ * copies and that both that copyright notice and this permission notice

+ * appear in supporting documentation, and that the name of M.I.T. not be

+ * used in advertising or publicity pertaining to distribution of the

+ * software without specific, written prior permission.  Furthermore if you

+ * modify this software you must label your software as modified software

+ * and not distribute it in such a fashion that it might be confused with

+ * the original MIT software. M.I.T. makes no representations about the

+ * suitability of this software for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ * 

+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

+ * 

+ * Individual source code files are copyright MIT, Cygnus Support,

+ * OpenVision, Oracle, Sun Soft, FundsXpress, and others.

+ * 

+ * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira,

+ * and Zephyr are trademarks of the Massachusetts Institute of Technology

+ * (MIT).  No commercial use of these trademarks may be made without prior

+ * written permission of MIT.

+ * 

+ * "Commercial use" means use of a name in a product or other for-profit

+ * manner.  It does NOT prevent a commercial firm from referring to the MIT

+ * trademarks in order to convey information (although in doing so,

+ * recognition of their trademark status should be given).

+ * $

+ */

+/*

+ * This is backwards compatibility for CCache API v2 clients to be able to run 

+ * against the CCache API v3 library

+ */

+ 

+#include "CredentialsCache2.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif /* __cplusplus */

+

+CCACHE_API cc_int32 cc_shutdown (

+        apiCB**				ioContext)

+{

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_get_NC_info (

+	apiCB*				inContext,

+	infoNC***			outInfo)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_get_change_time (

+	apiCB*				inContext,

+	cc_time*			outTime)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_open (

+	apiCB*				inContext,

+	const char*			inName,

+	cc_int32			inVersion,

+	cc_uint32			inFlags,

+	ccache_p**			outCCache)

+{

+    if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5)

+	return CC_ERR_CRED_VERSION;

+

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_create (

+	apiCB*				inContext,

+	const char*			inName,

+	const char*			inPrincipal,

+	cc_int32			inVersion,

+	cc_uint32			inFlags,

+	ccache_p**			outCCache)

+{

+    if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5)

+	return CC_ERR_CRED_VERSION;

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_close (

+	apiCB*				inContext,

+	ccache_p**			ioCCache)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_destroy (

+	apiCB*				inContext,

+	ccache_p**			ioCCache)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_seq_fetch_NCs_begin (

+	apiCB*				inContext,

+	ccache_cit**			outIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_seq_fetch_NCs_next (

+	apiCB*				inContext,

+	ccache_p**			outCCache,

+	ccache_cit*			inIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_seq_fetch_NCs_end (

+	apiCB*				inContext,

+	ccache_cit**			ioIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_get_name (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	char**				outName)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_get_cred_version (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	cc_int32*			outVersion)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_set_principal (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	cc_int32			inVersion,

+	char*				inPrincipal)

+{

+    if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5)

+	return CC_ERR_CRED_VERSION;

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_get_principal (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	char**				outPrincipal)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_store (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	cred_union			inCredentials)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_remove_cred (

+	apiCB*				inContext,

+	ccache_p*			inCCache,

+	cred_union			inCredentials)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_seq_fetch_creds_begin (

+	apiCB*				inContext,

+	const ccache_p*			inCCache,

+	ccache_cit**			outIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_seq_fetch_creds_next (

+	apiCB*				inContext,

+	cred_union**			outCreds,

+	ccache_cit*			inIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_seq_fetch_creds_end (

+	apiCB*				inContext,

+	ccache_cit**			ioIterator)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+	

+CCACHE_API cc_int32 cc_free_principal (

+	apiCB*				inContext,

+	char**				ioPrincipal)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_free_name (

+	apiCB*				inContext,

+	char**				ioName)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_free_creds (

+	apiCB*				inContext,

+	cred_union**			creds)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_free_NC_info (

+	apiCB*				inContext,

+	infoNC***			ioInfo)

+{

+	

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+CCACHE_API cc_int32 cc_lock_request(

+        apiCB* 				inContext,

+        const ccache_p* 		inCCache,

+        const cc_int32 			lock_type)

+{

+    /* replace this return value when the function is implemented */

+    return CC_NOT_SUPP;

+}

+

+

+#ifdef __cplusplus

+}

+#endif /* __cplusplus */

+

diff --git a/src/lib/ccapi/client/ccstring.c b/src/lib/ccapi/client/ccstring.c
index 419bfef772..6f3fa2bcbf 100644
--- a/src/lib/ccapi/client/ccstring.c
+++ b/src/lib/ccapi/client/ccstring.c
@@ -50,9 +50,9 @@
 #include "ccstring.h"
 
 cc_int32
-cc_int_string_new( cc_string_t * pstring, char * data )
+cci_string_new( cc_string_t * pstring, char * data )
 {
-    cc_int_string_t string = (cc_int_string_t)malloc(sizeof(cc_int_string_d));
+    cci_string_t string = (cci_string_t)malloc(sizeof(cci_string_d));
     if ( string == NULL )
         return ccErrNoMem;
 
@@ -63,7 +63,7 @@ cc_int_string_new( cc_string_t * pstring, char * data )
     }
 
     string->magic = CC_STRING_MAGIC;
-    string->functions->release = cc_int_string_release;
+    string->functions->release = cci_string_release;
 
     string->data = strdup(data);
     if ( string->data == NULL ) {
@@ -77,13 +77,13 @@ cc_int_string_new( cc_string_t * pstring, char * data )
 }
 
 cc_int32
-cc_int_string_release( cc_string_t str )
+cci_string_release( cc_string_t str )
 {
-    cc_int_string_t int_string;
+    cci_string_t int_string;
     if ( str == NULL )
         return ccErrBadParam;
 
-    int_string = (cc_int_string_t)str;
+    int_string = (cci_string_t)str;
     if ( int_string->magic != CC_STRING_MAGIC )
         return ccErrInvalidString;
 
diff --git a/src/lib/ccapi/client/ccstring.h b/src/lib/ccapi/client/ccstring.h
index 9e0ad223f5..2c973afbb5 100644
--- a/src/lib/ccapi/client/ccstring.h
+++ b/src/lib/ccapi/client/ccstring.h
@@ -45,7 +45,7 @@
 
 #define CC_STRING_MAGIC ('S'<<24 | 'T'<<16 | 'R'<<8 | 'I')
 
-struct cc_int_string_d {
+struct cci_string_d {
     char*         data;
     cc_string_f*  functions;
 #if TARGET_OS_MAC
@@ -53,13 +53,13 @@ struct cc_int_string_d {
 #endif
     cc_uint32           magic;
 };
-typedef struct cc_int_string_d cc_int_string_d;
-typedef cc_int_string_d*    cc_int_string_t;
+typedef struct cci_string_d cci_string_d;
+typedef cci_string_d*    cci_string_t;
 
 cc_int32
-cc_int_string_new( cc_string_t * pstring, char * data );
+cci_string_new( cc_string_t * pstring, char * data );
 
 cc_int32
-cc_int_string_release( cc_string_t string );
+cci_string_release( cc_string_t string );
 
 
diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c
index 86c41b8e70..5d88d46868 100644
--- a/src/lib/ccapi/client/context.c
+++ b/src/lib/ccapi/client/context.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -45,10 +45,20 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <CredentialsCache.h>
 #include "context.h"
+#include "ccache.h"
+#include "ccache_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
+#include "ccstring.h"
+
+/* cc_int_context_new
+ *
+ * input parameters (handle, version) are in host order 
+ */
 
 cc_int32
 cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version )
@@ -87,11 +97,12 @@ cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version
 cc_int32    
 cc_int_context_release( cc_context_t context )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_release_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -104,28 +115,38 @@ cc_int_context_release( cc_context_t context )
     request_header = (ccmsg_ctx_release_t*)malloc(sizeof(ccmsg_ctx_release_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_RELEASE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_release_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	request_header = NULL;
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     free(int_context->functions);
     free(int_context);
     return code;
@@ -133,14 +154,16 @@ cc_int_context_release( cc_context_t context )
 
 cc_int32
 cc_int_context_get_change_time( cc_context_t context,
-                                cc_time_t* time)
+                                cc_time* time)
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_get_change_time_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 		int_context;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ctx_get_change_time_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
     ccmsg_ctx_get_change_time_resp_t *response_header;
-    cc_int32 code;
+    cc_time64 		t64;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( context == NULL || time == NULL )
         return ccErrBadParam;
@@ -153,30 +176,42 @@ cc_int_context_get_change_time( cc_context_t context,
     request_header = (ccmsg_ctx_get_change_time_t*)malloc(sizeof(ccmsg_ctx_get_change_time_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_GET_CHANGE_TIME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_change_time_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
     } else if (response->type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_get_change_time_resp_t*)response->header;
-        *time = response_header->time;
+        t64 = ntohll(response_header->time);
+	/* TODO: validate that value is not greater than can fit in cc_time */
+	*time = (cc_time)t64;
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -184,12 +219,14 @@ cc_int32
 cc_int_context_get_default_ccache_name( cc_context_t context,
                                         cc_string_t* name )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_get_default_ccache_name_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_get_default_ccache_name_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_get_default_ccache_name_resp_t *response_header;
-    cc_int32 code;
+    char 		*string = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL )
         return ccErrBadParam;
@@ -202,35 +239,44 @@ cc_int_context_get_default_ccache_name( cc_context_t context,
     request_header = (ccmsg_ctx_get_default_ccache_name_t*)malloc(sizeof(ccmsg_ctx_get_default_ccache_name_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_GET_DEFAULT_CCACHE_NAME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_default_ccache_name_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
-        char * string;
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_get_default_ccache_name_resp_t*)response->header;
         code = cci_msg_retrieve_blob(response, response_header->name_offset, 
                                      response_header->name_len, &string);
-        if (code == ccNoError) {
-            code = cc_string_new(&name, string);
-            free(string);
-        }
+        if (code == ccNoError)
+            code = cci_string_new(name, string);
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (string)
+	free(string);
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -240,11 +286,12 @@ cc_int_context_compare( cc_context_t context,
                         cc_uint32* equal )
 {
     cc_int_context_t int_context, int_compare_to;
-    cc_msg_t        *request;
-    ccmsg_ctx_compare_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_compare_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_compare_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || compare_to == NULL || 
          equal == NULL )
@@ -260,31 +307,41 @@ cc_int_context_compare( cc_context_t context,
     request_header = (ccmsg_ctx_compare_t*)malloc(sizeof(ccmsg_ctx_compare_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx1 = int_context->handle;
-    request_header->ctx2 = int_compare_to->handle;
+    request_header->ctx1 = htonll(int_context->handle);
+    request_header->ctx2 = htonll(int_compare_to->handle);
 
     code = cci_msg_new(ccmsg_CTX_COMPARE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_compare_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_compare_resp_t*)response->header;
-        *equal = response_header->is_equal;
+        *equal = ntohl(response_header->is_equal);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -293,12 +350,13 @@ cc_int32
 cc_int_context_new_ccache_iterator( cc_context_t context,
                                     cc_ccache_iterator_t* iterator )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_new_ccache_iterator_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_new_ccache_iterator_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_new_ccache_iterator_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || iterator == NULL )
         return ccErrBadParam;
@@ -311,29 +369,40 @@ cc_int_context_new_ccache_iterator( cc_context_t context,
     request_header = (ccmsg_ctx_new_ccache_iterator_t*)malloc(sizeof(ccmsg_ctx_new_ccache_iterator_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_NEW_CCACHE_ITERATOR, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_new_ccache_iterator_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_new_ccache_iterator_resp_t*)response->header;
-        code = cc_int_ccache_iterator_new(iterator, int_context->handle, response_header->iterator);
+        code = cc_int_ccache_iterator_new(iterator, int_context->handle,
+					   ntohll(response_header->iterator));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -342,13 +411,14 @@ cc_int_context_open_ccache( cc_context_t context,
                             const char* name,
                             cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_open_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_open_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_open_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL || ccache == NULL )
         return ccErrBadParam;
@@ -362,38 +432,45 @@ cc_int_context_open_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_OPEN, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->ctx = int_context->handle;
-    request_header->name_offset = blob_pos;
-    request_header->name_len = strlen(name) + 1;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->name_offset = htonl(blob_pos);
+    request_header->name_len = htonl(strlen(name) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_open_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -401,12 +478,13 @@ cc_int32
 cc_int_context_open_default_ccache( cc_context_t context,
                                     cc_ccache_t* ccache)
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_open_default_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_open_default_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_open_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || ccache == NULL )
         return ccErrBadParam;
@@ -420,29 +498,39 @@ cc_int_context_open_default_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_OPEN_DEFAULT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN_DEFAULT, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_default_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_open_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -453,13 +541,14 @@ cc_int_context_create_ccache( cc_context_t context,
                               const char* principal, 
                               cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL || 
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -475,48 +564,53 @@ cc_int_context_create_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
-    request_header->name_offset = blob_pos;
-    request_header->name_len = strlen(name) + 1;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
+    request_header->name_offset = htonl(blob_pos);
+    request_header->name_len = htonl(strlen(name) + 1);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -526,13 +620,14 @@ cc_int_context_create_default_ccache( cc_context_t context,
                                       const char* principal, 
                                       cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_default_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_default_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL ||
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -548,39 +643,47 @@ cc_int_context_create_default_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE_DEFAULT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_DEFAULT, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_default_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -590,13 +693,14 @@ cc_int_context_create_new_ccache( cc_context_t context,
                                   const char* principal, 
                                   cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_unique_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_unique_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL ||
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -612,39 +716,47 @@ cc_int_context_create_new_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE_UNIQUE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_UNIQUE, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_unique_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = htonl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response-> header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
  
@@ -653,14 +765,16 @@ cc_int_context_lock( cc_context_t context,
                      cc_uint32 lock_type,
                      cc_uint32 block )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_lock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_lock_t 	*request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || 
-         (lock_type != cc_lock_read && lock_type != cc_lock_write) ||
+         (lock_type != cc_lock_read && lock_type != cc_lock_write &&
+	  lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) ||
          (block != cc_lock_block && block != cc_lock_noblock) )
         return ccErrBadParam;
 
@@ -674,41 +788,52 @@ cc_int_context_lock( cc_context_t context,
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CTX_LOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->lock_type;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->lock_type = htonl(lock_type);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_lock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
 
         // TODO: if (block == cc_lock_block) .....
-    } else if (response->type == ccmsg_ACK) {
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
 cc_int_context_unlock( cc_context_t context )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_unlock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_unlock_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -723,27 +848,37 @@ cc_int_context_unlock( cc_context_t context )
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CTX_UNLOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_unlock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -754,20 +889,22 @@ cc_int_context_clone( cc_context_t      inContext,
                       cc_int32*         supportedVersion,
                       char const**      vendor )
 {
-    cc_int_context_t int_context, new_context;
-    static char vendor_st[128] = "";
-    cc_msg_t     *request;
-    ccmsg_clone_t *request_header;
-    cc_msg_t     *response;
-    ccmsg_clone_resp_t *response_header;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    static char 	vendor_st[128] = "";
+    cc_msg_t     	*request = NULL;
+    ccmsg_ctx_clone_t 	*request_header = NULL;
+    cc_msg_t     	*response = NULL;
+    ccmsg_ctx_clone_resp_t *response_header;
+    char 		*string = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( inContext == NULL ||
          outContext == NULL ||
          supportedVersion == NULL )
         return ccErrBadParam;
 
-    int_context = (cc_int_context_t)context;
+    int_context = (cc_int_context_t)inContext;
 
     if ( int_context->magic != CC_CONTEXT_MAGIC )
         return ccErrInvalidContext;
@@ -775,45 +912,48 @@ cc_int_context_clone( cc_context_t      inContext,
     if ((requestedVersion != ccapi_version_2) &&
          (requestedVersion != ccapi_version_3) &&
          (requestedVersion != ccapi_version_4) &&
-         (requestedVersion != ccapi_version_5)) {
+         (requestedVersion != ccapi_version_5) &&
+	 (requestedVersion != ccapi_version_6)) {
 
         if (supportedVersion != NULL) {
-            *supportedVersion = ccapi_version_5;
+            *supportedVersion = ccapi_version_max;
         }
         return ccErrBadAPIVersion;
     }   
 
-    request_header = (ccmsg_clone_t*)malloc(sizeof(ccmsg_clone_t));
+    request_header = (ccmsg_ctx_clone_t*)malloc(sizeof(ccmsg_ctx_clone_t));
     if (request_header == NULL)
         return ccErrNoMem;
 
-    request_header->ctx = int_context->handle;
-    request_header->in_version = requestedVersion;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->in_version = htonl(requestedVersion);
 
     code = cci_msg_new(ccmsg_INIT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_init_t));
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_clone_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
-        response_header = (ccmsg_clone_resp_t *)response->header;
-        *supportedVersion = response_header->out_version;
-        code = cc_int_context_new(outContext, response_header->out_ctx, response_header->out_version);
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
+        response_header = (ccmsg_ctx_clone_resp_t *)response->header;
+        *supportedVersion = ntohl(response_header->out_version);
+        code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version));
 
         if (!vendor_st[0]) {
-            char * string;
-            code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string);
+            code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string);
             strncpy(vendor_st, string, sizeof(vendor_st)-1);
             vendor_st[sizeof(vendor_st)-1] = '\0';
-            free(string);
         } 
         *vendor = vendor_st;
 
@@ -821,8 +961,16 @@ cc_int_context_clone( cc_context_t      inContext,
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (string)
+	free(string);
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -831,7 +979,6 @@ cc_int_context_get_version( cc_context_t        context,
                             cc_int32*           version )
 {
     cc_int_context_t int_context;
-    cc_int32 code;
 
     if ( context == NULL ||
          version == NULL )
diff --git a/src/lib/ccapi/client/context.h b/src/lib/ccapi/client/context.h
index cd5ca678d4..6ff113a269 100644
--- a/src/lib/ccapi/client/context.h
+++ b/src/lib/ccapi/client/context.h
@@ -66,7 +66,7 @@ cc_int_context_release( cc_context_t context );
 
 cc_int32
 cc_int_context_get_change_time( cc_context_t context,
-                                cc_time_t* time);
+                                cc_time* time);
 
 cc_int32
 cc_int_context_get_default_ccache_name( cc_context_t context,
diff --git a/src/lib/ccapi/client/credentials.c b/src/lib/ccapi/client/credentials.c
index b0a3df2b75..dbdf6345e8 100644
--- a/src/lib/ccapi/client/credentials.c
+++ b/src/lib/ccapi/client/credentials.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -88,10 +88,10 @@ cc_int_credentials_new( cc_credentials_t *pcredentials, cc_uint32 version,
 
     switch ( version ) {
     case cc_credentials_v4:
-        code = cci_cred_v4_unmarshall(data, len, credentials->data);
+        code = cci_creds_v4_unmarshall(data, len, credentials->data);
         break;
     case cc_credentials_v5:
-        code = cci_cred_v5_unmarshall(data, len, credentials->data);
+        code = cci_creds_v5_unmarshall(data, len, credentials->data);
         break;
     default:
         free(credentials);
@@ -159,23 +159,23 @@ cc_int_credentials_release( cc_credentials_t creds )
 
 cc_int32
 cc_int_credentials_compare( cc_credentials_t credentials,
-                        cc_credentials_t compare_to,
-                        cc_uint32* equal )
+			    cc_credentials_t compare_to,
+			    cc_uint32* equal )
 {
     cc_int_credentials_t int_credentials;
     cc_int_credentials_t int_compare_to;
 
     if ( credentials == NULL || compare_to == NULL || equal == NULL )
         return ccErrBadParam;
-
     
+    int_credentials = (cc_int_credentials_t)credentials;
+    int_compare_to  = (cc_int_credentials_t)compare_to;
+
     if ( int_credentials->magic != CC_CREDS_MAGIC ||
          int_compare_to->magic != CC_CREDS_MAGIC )
         return ccErrInvalidCredentials;
 
-    int_credentials = (cc_int_credentials_t)credentials;
-    int_compare_to  = (cc_int_credentials_t)compare_to;
-
     *equal = (int_credentials->handle == int_compare_to->handle);
+   
     return ccNoError;
 }
diff --git a/src/lib/ccapi/client/credentials.h b/src/lib/ccapi/client/credentials.h
index 320c618257..dfd589f326 100644
--- a/src/lib/ccapi/client/credentials.h
+++ b/src/lib/ccapi/client/credentials.h
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -84,8 +84,8 @@ cci_creds_v5_marshall( cc_credentials_v5_t * creds,
 
 cc_int32
 cci_creds_v4_unmarshall( char * flat, 
-                             cc_uint32 len,
-                             cc_credentials_union * creds);
+                         cc_uint32 len,
+                         cc_credentials_union * creds);
 
 cc_int32
 cci_creds_v5_unmarshall( char * flat, 
diff --git a/src/lib/ccapi/client/credentials_iterator.c b/src/lib/ccapi/client/credentials_iterator.c
index b7333daf30..3cdab875a3 100644
--- a/src/lib/ccapi/client/credentials_iterator.c
+++ b/src/lib/ccapi/client/credentials_iterator.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -46,7 +46,9 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <CredentialsCache.h>
+#include "credentials.h"
 #include "credentials_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
 
@@ -74,6 +76,7 @@ cc_int_credentials_iterator_new( cc_credentials_iterator_t * piter,
 
     iter->functions->release = cc_int_credentials_iterator_release;
     iter->functions->next = cc_int_credentials_iterator_next;
+    iter->functions->clone = cc_int_credentials_iterator_clone;
     iter->magic = CC_CREDS_ITER_MAGIC;
     iter->ctx = ctx;
     iter->ccache = ccache;
@@ -87,10 +90,11 @@ cc_int32
 cc_int_credentials_iterator_release( cc_credentials_iterator_t iter )
 {
     cc_int_credentials_iterator_t int_iter;
-    cc_msg_t        *request;
-    ccmsg_creds_iterator_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        		*request = NULL;
+    ccmsg_creds_iterator_release_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( iter == NULL )
         return ccErrBadParam;
@@ -103,29 +107,40 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter )
     request_header = (ccmsg_creds_iterator_release_t*)malloc(sizeof(ccmsg_creds_iterator_release_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_iter->ctx;
-    request_header->ccache = int_iter->ccache;
-    request_header->iterator = int_iter->handle;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->ccache = htonll(int_iter->ccache);
+    request_header->iterator = htonll(int_iter->handle);
+
     code = cci_msg_new(ccmsg_CREDS_ITERATOR_RELEASE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_release_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = htonl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = htonl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
 
     free(int_iter->functions);
     free(int_iter);
@@ -137,10 +152,11 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter,
                                   cc_credentials_t * credentials )
 {
     cc_int_credentials_iterator_t int_iter;
-    cc_msg_t        *request;
-    ccmsg_creds_iterator_next_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        		*request = NULL;
+    ccmsg_creds_iterator_next_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( credentials == NULL )
         return ccErrBadParam;
@@ -153,35 +169,105 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter,
     request_header = (ccmsg_creds_iterator_next_t*)malloc(sizeof(ccmsg_creds_iterator_next_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_iter->ctx;
-    request_header->ccache = int_iter->ccache;
-    request_header->iterator = int_iter->handle;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->ccache = htonll(int_iter->ccache);
+    request_header->iterator = htonll(int_iter->handle);
 
     code = cci_msg_new(ccmsg_CREDS_ITERATOR_NEXT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_next_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         char * blob;
         ccmsg_creds_iterator_next_resp_t * response_header = (ccmsg_creds_iterator_next_resp_t*)response->header;
-        code = cci_msg_retrieve_blob(response, response_header->creds_offset, response_header->creds_len, &blob);
-        code = cc_credentials_new(credentials, response_header->version,
-                                  int_iter->ctx, int_iter->ccache, response_header->creds_handle, 
-                                  blob, response_header->creds_len);
+        code = cci_msg_retrieve_blob(response, ntohl(response_header->creds_offset), ntohl(response_header->creds_len), &blob);
+        code = cc_int_credentials_new(credentials, ntohl(response_header->version),
+                                  int_iter->ctx, int_iter->ccache, ntohll(response_header->creds_handle), 
+                                  blob, ntohl(response_header->creds_len));
         free(blob);
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
+    return code;
+}
+
+cc_int32
+cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter,
+				   cc_credentials_iterator_t* new_iter)
+{
+    cc_int_credentials_iterator_t 	int_iter;
+    cc_msg_t        			*request = NULL;
+    ccmsg_creds_iterator_clone_t 	*request_header = NULL;
+    cc_msg_t        			*response = NULL;
+    cc_uint32				type;
+    cc_int32 				code;
+
+    if ( iter == NULL || new_iter == NULL )
+        return ccErrBadParam;
+
+    int_iter = (cc_int_credentials_iterator_t)iter;
+
+    if ( int_iter->magic != CC_CREDS_ITER_MAGIC )
+        return ccErrInvalidCCacheIterator;
+
+    request_header = (ccmsg_creds_iterator_clone_t*)malloc(sizeof(ccmsg_creds_iterator_clone_t));
+    if (request_header == NULL)
+        return ccErrNoMem;
+    request_header->ctx = htonll(int_iter->ctx);
+    request_header->iterator = htonll(int_iter->handle);
+
+    code = cci_msg_new(ccmsg_CREDS_ITERATOR_CLONE, &request);
+    if (code != ccNoError)
+	goto cleanup;
+
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_clone_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
+
+    code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
+
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
+        ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
+        ccmsg_creds_iterator_clone_resp_t * response_header = (ccmsg_creds_iterator_clone_resp_t*)response->header;
+        code = cc_int_credentials_iterator_new(new_iter, int_iter->ctx, int_iter->ccache, ntohll(response_header->iterator));
+    } else {
+        code = ccErrBadInternalMessage;
+    }
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
+
diff --git a/src/lib/ccapi/client/credentials_iterator.h b/src/lib/ccapi/client/credentials_iterator.h
index 2a6f8edf2d..954d2f1afa 100644
--- a/src/lib/ccapi/client/credentials_iterator.h
+++ b/src/lib/ccapi/client/credentials_iterator.h
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -69,4 +69,8 @@ cc_int32
 cc_int_credentials_iterator_next( cc_credentials_iterator_t iter,
                                   cc_credentials_t * credentials );
 
+cc_int32
+cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter,
+                                   cc_credentials_iterator_t * new_iter );
+