Updates of portable CCAPI sources. All code compiles

git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18022 dc483132-0cff-0310-8789-dd5450dbe970

16 files changed, 2057 insertions, 437 deletions

diff --git a/src/lib/ccapi/client/NTMakefile b/src/lib/ccapi/client/NTMakefile
index 09ef9df38..57ff87416 100644
--- a/src/lib/ccapi/client/NTMakefile
+++ b/src/lib/ccapi/client/NTMakefile
@@ -12,11 +12,11 @@ $(CCAPI_LIB): $(CCAPI_OBJS)
 
 CCAPI_DLLFILE = krbcc32.dll
 
-
-
 $(CCAPI_DLLFILE): $(CCAPI_LIB)
         $(DLLGUILINK) -def:windows\krbcc32.def
         $(DLLPREP)
 
+all: $(CCAPI_DLLFILE)
+
 clean:
         del *.obj *.lib
diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c
index 2c874bec0..704925dfd 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.
  * 
@@ -47,10 +47,17 @@
 #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,
@@ -60,16 +67,18 @@ cc_initialize (	cc_context_t*		outContext,
     cc_msg_t     *request;
     ccmsg_init_t *request_header;
     cc_msg_t     *response;
+    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,7 +87,17 @@ 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) {
@@ -90,17 +109,18 @@ cc_initialize (	cc_context_t*		outContext,
 
     code = cci_perform_rpc(request, &response);
 
-    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, ntohl(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);
diff --git a/src/lib/ccapi/client/cacheapi.def b/src/lib/ccapi/client/cacheapi.def
new file mode 100644
index 000000000..c54cc1106
--- /dev/null
+++ b/src/lib/ccapi/client/cacheapi.def
@@ -0,0 +1,29 @@
+EXPORTS

+	; ccapi v3 only exports one function

+        cc_initialize			@14

+

+	; ccapi v2 compatibility functions

+        cc_close 			@2

+        cc_create			@3

+        cc_destroy			@4

+        cc_free_NC_info			@5

+        cc_free_creds			@6

+        cc_free_name			@7

+        cc_free_principal		@8

+        cc_get_NC_info			@9

+        cc_get_change_time		@10

+        cc_get_cred_version		@11

+        cc_get_name			@12

+        cc_get_principal		@13

+        cc_lock_request			@15

+        cc_open				@16

+        cc_remove_cred			@17

+        cc_seq_fetch_NCs_begin		@18

+        cc_seq_fetch_NCs_end		@19

+        cc_seq_fetch_NCs_next		@20

+        cc_seq_fetch_creds_begin	@21

+        cc_seq_fetch_creds_end		@22

+        cc_seq_fetch_creds_next		@23

+        cc_set_principal		@24

+        cc_shutdown			@25

+        cc_store			@26

diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c
index 5de3880e4..42064d54d 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.
  * 
@@ -49,9 +49,16 @@
 #include <CredentialsCache.h>
 #include "credentials.h"
 #include "ccache.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.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 +104,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;
+    ccmsg_ccache_release_t 	*request_header;
+    cc_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -114,8 +122,8 @@ 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) {
@@ -127,10 +135,11 @@ cc_int_ccache_release( cc_ccache_t ccache )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -146,11 +155,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;
+    ccmsg_ccache_destroy_t 	*request_header;
+    cc_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -163,8 +173,8 @@ 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) {
@@ -176,10 +186,11 @@ cc_int_ccache_destroy( cc_ccache_t ccache )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -194,11 +205,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;
+    ccmsg_ccache_set_default_t 		*request_header;
+    cc_msg_t        			*response;
+    cc_uint32				type;
+    cc_int32 				code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -211,8 +223,8 @@ 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) {
@@ -224,10 +236,11 @@ cc_int_ccache_set_default( cc_ccache_t ccache )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -241,11 +254,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;
+    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_msg_t        		*response;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -258,8 +272,8 @@ 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) {
@@ -271,12 +285,13 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -287,14 +302,14 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache,
 }
 
 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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -307,8 +322,8 @@ 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) {
@@ -320,10 +335,11 @@ cc_int_ccache_get_name( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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, 
@@ -345,11 +361,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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -362,9 +379,9 @@ 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) {
@@ -376,10 +393,11 @@ cc_int_ccache_get_principal( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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, 
@@ -401,12 +419,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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -419,9 +438,9 @@ 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) {
@@ -436,17 +455,18 @@ cc_int_ccache_set_principal( cc_ccache_t ccache,
         return code;
     }
     
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -460,11 +480,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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -477,10 +498,10 @@ 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);
+    code = cci_msg_new(ccmsg_CCACHE_NEW_CREDS_ITERATOR, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
@@ -490,12 +511,14 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
     }
@@ -508,14 +531,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;
+    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_msg_t        	*response;
+    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,8 +552,8 @@ 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) {
@@ -562,18 +586,19 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache,
         return code;
     }
     
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -588,12 +613,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;
+    ccmsg_ccache_rem_creds_t 	*request_header;
+    cc_msg_t        		*response;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL || credentials == NULL )
         return ccErrBadParam;
@@ -611,9 +637,9 @@ 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) {
@@ -625,10 +651,11 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -643,12 +670,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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( source == NULL || destination == NULL )
         return ccErrBadParam;
@@ -673,18 +701,19 @@ cc_int_ccache_move( cc_ccache_t source,
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -698,14 +727,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;
+    cc_int_ccache_t 	int_ccache;
+    cc_msg_t        	*request;
     ccmsg_ccache_lock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        	*response;
+    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;
 
@@ -724,17 +755,18 @@ cc_int_ccache_lock( cc_ccache_t ccache,
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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) {
@@ -750,11 +782,12 @@ cc_int_ccache_lock( cc_ccache_t ccache,
 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;
+    ccmsg_ccache_unlock_t 	*request_header;
+    cc_msg_t        		*response;
+    cc_uint32 			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -774,17 +807,18 @@ cc_int_ccache_unlock( cc_ccache_t ccache )
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -797,13 +831,15 @@ 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_offset )
+                                     cc_time* time_offset )
 {
-    cc_int_ccache_t int_ccache;
-    cc_msg_t        *request;
+    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_msg_t        		*response;
+    cc_uint32			type;
+    cc_time64			t64;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -816,8 +852,8 @@ 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) {
@@ -829,13 +865,16 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
     }
@@ -845,14 +884,15 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache,
 }
 
 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;
+    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_msg_t        	*response;
+    cc_time64		t64;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -865,8 +905,8 @@ 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) {
@@ -878,12 +918,15 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -898,12 +941,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;
+    ccmsg_ccache_compare_t 	*request_header;
+    cc_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -918,9 +962,9 @@ 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) {
@@ -932,12 +976,13 @@ cc_int_ccache_compare( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -950,13 +995,14 @@ 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_int_ccache_t int_ccache;
-    cc_msg_t        *request;
+    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_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -969,9 +1015,9 @@ 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) {
@@ -983,12 +1029,13 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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 = ntohll(response_header->offset);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
@@ -1001,13 +1048,15 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache,
 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;
+    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_msg_t        	*response;
+    cc_int64		t64;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -1020,9 +1069,11 @@ 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) {
@@ -1034,10 +1085,11 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -1051,11 +1103,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;
+    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_msg_t        	*response;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -1068,9 +1121,9 @@ 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) {
@@ -1082,10 +1135,11 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t	ccache,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -1094,5 +1148,3 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t	ccache,
     cci_msg_destroy(response);
     return code;
 }
-
-
diff --git a/src/lib/ccapi/client/ccache.h b/src/lib/ccapi/client/ccache.h
index e3b3993ee..0a92ebf63 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 03266b1bb..3f3e1675e 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.
  * 
@@ -47,6 +47,7 @@
 #include <stdio.h>
 #include <CredentialsCache.h>
 #include "ccache_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
 
@@ -84,11 +85,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;
+    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_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
 
     if ( iter == NULL )
@@ -102,8 +104,8 @@ 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);
@@ -114,10 +116,11 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -134,11 +137,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;
+    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_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( ccache == NULL )
         return ccErrBadParam;
@@ -151,8 +155,8 @@ 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) {
@@ -164,12 +168,63 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter,
 
     code = cci_perform_rpc(request, &response);
 
-    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);
+    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;
+    ccmsg_ccache_iterator_clone_t *request_header;
+    cc_msg_t        		*response;
+    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) {
+        free(request_header);
+        return code;
+    }
+
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_clone_t));
+
+    code = cci_perform_rpc(request, &response);
+
+    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;
     }
diff --git a/src/lib/ccapi/client/ccache_iterator.h b/src/lib/ccapi/client/ccache_iterator.h
index c55d72ee6..5a390b82e 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 000000000..ffbb589a2
--- /dev/null
+++ b/src/lib/ccapi/client/ccapiv2.c
@@ -0,0 +1,286 @@
+/* $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_t*			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;

+}

+

+

+#ifdef __cplusplus

+}

+#endif /* __cplusplus */

+

diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c
index 86c41b8e7..efac3020c 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.
  * 
@@ -47,9 +47,15 @@
 #include <stdio.h>
 #include <CredentialsCache.h>
 #include "context.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.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 +93,13 @@ 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;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request;
     ccmsg_ctx_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        	*response;
+    cc_uint32 		type;
+    cc_time64		t64;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -104,7 +112,7 @@ 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 = htonl(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_RELEASE, &request);
     if (code != ccNoError) {
@@ -116,10 +124,11 @@ cc_int_context_release( cc_context_t context )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -133,14 +142,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;
+    cc_int_context_t 		int_context;
+    cc_msg_t        		*request;
     ccmsg_ctx_get_change_time_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        		*response;
     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,7 +164,7 @@ 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) {
@@ -165,12 +176,15 @@ cc_int_context_get_change_time( cc_context_t context,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -184,12 +198,13 @@ 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;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request;
     ccmsg_ctx_get_default_ccache_name_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        	*response;
     ccmsg_ctx_get_default_ccache_name_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL )
         return ccErrBadParam;
@@ -202,7 +217,7 @@ 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) {
@@ -214,10 +229,11 @@ cc_int_context_get_default_ccache_name( cc_context_t context,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
         response_header = (ccmsg_ctx_get_default_ccache_name_resp_t*)response->header;
         code = cci_msg_retrieve_blob(response, response_header->name_offset, 
@@ -244,7 +260,8 @@ cc_int_context_compare( cc_context_t context,
     ccmsg_ctx_compare_t *request_header;
     cc_msg_t        *response;
     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,8 +277,8 @@ 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 = htonl(int_context->handle);
+    request_header->ctx2 = htonl(int_compare_to->handle);
 
     code = cci_msg_new(ccmsg_CTX_COMPARE, &request);
     if (code != ccNoError) {
@@ -273,12 +290,13 @@ cc_int_context_compare( cc_context_t context,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -293,12 +311,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;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request;
     ccmsg_ctx_new_ccache_iterator_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        	*response;
     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,7 +330,7 @@ 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) {
@@ -323,12 +342,14 @@ cc_int_context_new_ccache_iterator( cc_context_t context,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
     }
@@ -342,13 +363,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;
+    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_msg_t        	*response;
     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,7 +384,7 @@ cc_int_context_open_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_OPEN, &request);
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
@@ -375,20 +397,21 @@ cc_int_context_open_ccache( cc_context_t context,
         return code;
     }
     
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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_cache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
@@ -401,12 +424,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;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request;
     ccmsg_ccache_open_default_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        	*response;
     ccmsg_ccache_open_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || ccache == NULL )
         return ccErrBadParam;
@@ -420,24 +444,25 @@ 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);
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN_DEFAULT, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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_cache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
@@ -453,13 +478,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;
+    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_msg_t        	*response;
     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,7 +501,7 @@ cc_int_context_create_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE, &request);
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
@@ -488,10 +514,10 @@ cc_int_context_create_ccache( cc_context_t context,
         return code;
     }
     
-    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) {
@@ -499,19 +525,20 @@ cc_int_context_create_ccache( cc_context_t context,
         free(request_header);
         return code;
     }
-    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_create_t));
 
     code = cci_perform_rpc(request, &response);
 
-    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_cache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
@@ -526,13 +553,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;
+    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_msg_t        	*response;
     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,14 +576,14 @@ 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);
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_DEFAULT, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
     }
 
-    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) {
@@ -563,19 +591,20 @@ cc_int_context_create_default_ccache( cc_context_t context,
         free(request_header);
         return code;
     }
-    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_create_default_t));
 
     code = cci_perform_rpc(request, &response);
 
-    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_cache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
@@ -590,13 +619,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;
+    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_msg_t        	*response;
     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,14 +642,14 @@ 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);
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_UNIQUE, &request);
     if (code != ccNoError) {
         free(request_header);
         return code;
     }
 
-    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) {
@@ -627,19 +657,20 @@ cc_int_context_create_new_ccache( cc_context_t context,
         free(request_header);
         return code;
     }
-    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_create_unique_t));
 
     code = cci_perform_rpc(request, &response);
 
-    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_cache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
@@ -653,14 +684,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;
+    ccmsg_ctx_lock_t 	*request_header;
+    cc_msg_t        	*response;
+    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;
 
@@ -679,19 +712,20 @@ cc_int_context_lock( cc_context_t context,
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -704,11 +738,12 @@ cc_int_context_lock( cc_context_t context,
 cc_int32
 cc_int_context_unlock( cc_context_t context )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request;
     ccmsg_ctx_unlock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        	*response;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -728,16 +763,17 @@ cc_int_context_unlock( cc_context_t context )
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -754,20 +790,21 @@ 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, new_context;
+    static char 	vendor_st[128] = "";
+    cc_msg_t     	*request;
+    ccmsg_ctx_clone_t 	*request_header;
+    cc_msg_t     	*response;
+    ccmsg_ctx_clone_resp_t *response_header;
+    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,20 +812,21 @@ 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) {
@@ -796,21 +834,22 @@ cc_int_context_clone( cc_context_t      inContext,
         return code;
     }
 
-    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));
 
     code = cci_perform_rpc(request, &response);
 
-    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), nthol(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);
diff --git a/src/lib/ccapi/client/context.h b/src/lib/ccapi/client/context.h
index cd5ca678d..6ff113a26 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 b0a3df2b7..8b8867689 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.
  * 
@@ -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 320c61825..dfd589f32 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 b7333daf3..bae60ffdf 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.
  * 
@@ -47,6 +47,7 @@
 #include <stdio.h>
 #include <CredentialsCache.h>
 #include "credentials_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
 
@@ -74,6 +75,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 +89,11 @@ cc_int32
 cc_int_credentials_iterator_release( cc_credentials_iterator_t iter )
 {
     cc_int_credentials_iterator_t int_iter;
-    cc_msg_t        *request;
+    cc_msg_t        		*request;
     ccmsg_creds_iterator_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( iter == NULL )
         return ccErrBadParam;
@@ -103,9 +106,10 @@ 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);
@@ -116,10 +120,11 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter )
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -137,10 +142,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;
+    cc_msg_t        		*request;
     ccmsg_creds_iterator_next_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_msg_t        		*response;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( credentials == NULL )
         return ccErrBadParam;
@@ -153,9 +159,9 @@ 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) {
@@ -167,16 +173,17 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter,
 
     code = cci_perform_rpc(request, &response);
 
-    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;
@@ -185,3 +192,54 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter,
     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;
+    ccmsg_creds_iterator_clone_t 	*request_header;
+    cc_msg_t        			*response;
+    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) {
+        free(request_header);
+        return code;
+    }
+
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_clone_t));
+
+    code = cci_perform_rpc(request, &response);
+
+    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;
+    }
+    cci_msg_destroy(request);
+    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 2a6f8edf2..954d2f1af 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 );
+
 
diff --git a/src/lib/ccapi/client/marshall.c b/src/lib/ccapi/client/marshall.c
new file mode 100644
index 000000000..31ebacd7b
--- /dev/null
+++ b/src/lib/ccapi/client/marshall.c
@@ -0,0 +1,445 @@
+/* $Copyright:

+ *

+ * Copyright 2004-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).

+ * $

+ */

+

+/* marshall.c */

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <CredentialsCache.h>

+#include "msg.h"

+#include "msg_headers.h"

+#include "marshall.h"

+

+cc_int32

+cci_creds_v4_marshall( cc_credentials_v4_t * creds, 

+                       char ** pflat, 

+                       cc_uint32 * plen)

+{

+    cc_uint32 len;

+    char * flat;

+    cci_flat_creds_v4_t * header;

+    cc_uint32 length;

+    cc_time64 t64;

+

+    if ( creds == NULL || pflat == NULL || plen == NULL )

+        return ccErrBadParam;

+

+    len = sizeof(cci_flat_creds_v4_t);

+    flat = (char *)malloc(len);

+    if ( flat == NULL )

+        return ccErrNoMem;

+    memset(flat, 0, len);

+

+    header = (cci_flat_creds_v4_t *)flat;

+    header->version = htonl(creds->version);

+    memcpy(header->principal, creds->principal, cc_v4_name_size);

+    memcpy(header->principal_instance, creds->principal_instance, cc_v4_instance_size);

+    memcpy(header->service, creds->service, cc_v4_name_size);

+    memcpy(header->service_instance, creds->service_instance, cc_v4_instance_size);

+    memcpy(header->realm, creds->realm, cc_v4_realm_size);

+    memcpy(header->session_key, creds->session_key, cc_v4_key_size);

+    header->kvno = htonl(creds->kvno);

+    header->string_to_key_type = htonl(creds->string_to_key_type);

+    t64 = creds->issue_date;

+    header->issue_date = htonll(t64);

+    header->lifetime = htonl(creds->lifetime);

+    /* TODO: verify that address is stored in host order */

+    header->address = htonl(creds->address);

+    header->ticket_size = htonl(creds->ticket_size);

+    memcpy(header->ticket, creds->ticket, cc_v4_ticket_size);

+

+    *pflat = flat;

+    *plen = len;

+

+    return ccNoError;	

+}

+

+cc_int32

+cci_creds_v4_unmarshall( char * flat, 

+                         cc_uint32 len,

+                         cc_credentials_union * creds_union)

+{

+    struct cci_flat_creds_v4 * header;

+    cc_credentials_v4_t * creds;

+    cc_flat_data * flat_data;

+    cc_time64 t64;

+    cc_uint32  length;

+    cc_int32   code;

+

+    if ( flat == NULL || len == 0 || creds_union == NULL )

+        return ccErrBadParam;

+

+    creds_union->version = cc_credentials_v4;

+

+    header = (cci_flat_creds_v4_t *)flat;

+

+    creds = (cc_credentials_v4_t *)malloc(sizeof(cc_credentials_v4_t));

+    if ( creds == NULL )

+	return ccErrNoMem;

+

+    creds->version = ntohl(header->version);

+    memcpy(creds->principal, header->principal, cc_v4_name_size);

+    memcpy(creds->principal_instance, header->principal_instance, cc_v4_instance_size);

+    memcpy(creds->service, header->service, cc_v4_name_size);

+    memcpy(creds->service_instance, header->service_instance, cc_v4_instance_size);

+    memcpy(creds->realm, header->realm, cc_v4_realm_size);

+    memcpy(creds->session_key, header->session_key, cc_v4_key_size);

+    creds->kvno = htonl(header->kvno);

+    creds->string_to_key_type = htonl(header->string_to_key_type);

+    t64 = header->issue_date;

+    creds->issue_date = ntohll(t64);

+    creds->lifetime = ntohl(header->lifetime);

+    /* TODO: verify that address is stored in host order */

+    creds->address = ntohl(header->address);

+    creds->ticket_size = ntohl(header->ticket_size);

+    memcpy(creds->ticket, header->ticket, cc_v4_ticket_size);

+

+    creds_union->credentials.credentials_v4 = creds;

+

+    return ccNoError;

+}

+

+

+cc_int32

+cci_creds_cc_data_array_count_entries( cc_data ** array, cc_uint32 * pcount)

+{

+    cc_uint32 count;

+

+    if (array == NULL) {

+        *pcount = 0;

+        return ccNoError;

+    }

+

+    for ( count=0; array[count] != NULL ; count++) ;

+

+    *pcount = count;

+    return ccNoError;

+}

+

+cc_int32

+cci_creds_v5_compute_flat_size( cc_credentials_v5_t * creds, cc_uint32 * plen)

+{

+    cc_uint32 len;

+    cc_uint32 i, count;

+

+    len = sizeof(struct cci_flat_creds_v5);

+

+    if (creds->client)

+        len += strlen(creds->client) + 1;

+

+    if (creds->server)

+        len += strlen(creds->server) + 1;

+

+    len += creds->keyblock.length;

+

+    cci_creds_cc_data_array_count_entries( creds->addresses, &count );

+    len += count * sizeof(cc_flat_data);

+    for ( i=0; i<count; i++ ) {

+        len += creds->addresses[i]->length;

+    }

+

+    len += creds->ticket.length;

+    len += creds->second_ticket.length;

+

+    cci_creds_cc_data_array_count_entries( creds->authdata, &count );

+    len += count * sizeof(cc_flat_data);

+    for ( i=0; i<count; i++ ) {

+        len += creds->authdata[i]->length;

+    }

+

+    *plen = len;

+    return ccNoError;

+}

+

+cc_int32

+cci_creds_v5_marshall( cc_credentials_v5_t * creds, 

+                       char ** pflat, 

+                       cc_uint32 * plen)

+{

+    cc_uint32 len;

+    char * flat;

+    struct cci_flat_creds_v5 * header;

+    cc_uint32 length;

+    cc_uint32 offset;

+    cc_time64 t64;

+    cc_uint32 count;

+    cc_uint32 i;

+

+    if ( creds == NULL || pflat == NULL || plen == NULL )

+        return ccErrBadParam;

+

+    cci_creds_v5_compute_flat_size(creds, &len);

+

+    flat = (char *)malloc(len);

+    if ( flat == NULL )

+        return ccErrNoMem;

+    memset(flat, 0, len);

+

+    offset = sizeof(struct cci_flat_creds_v5);

+    header = (struct cci_flat_creds_v5 *)flat;

+    header->version = htonl(FLAT_CREDS_V5_VERSION);

+    if (creds->client) {

+	length = strlen(creds->client) + 1;

+        header->client.length = htonl(length);

+        header->client.data = htonl(offset);

+        memcpy(flat + offset, creds->client, length);

+        offset += length;

+    }

+

+    if (creds->server) {

+	length = strlen(creds->server) + 1;

+        header->server.length = htonl(length);

+        header->server.data = htonl(offset);

+        memcpy(flat + offset, creds->server, length);

+        offset += length;

+    }

+

+    header->keyblock.type = htonl(creds->keyblock.type);

+    if (creds->keyblock.length) {

+	length = creds->keyblock.length;

+        header->keyblock.length = htonl(length);

+        header->keyblock.data = htonl(offset);

+        memcpy(flat + offset, creds->keyblock.data, length);

+        offset += length;

+    }           

+

+    t64 = creds->authtime;

+    header->authtime = htonll(t64);

+    t64 = creds->starttime;

+    header->starttime = htonll(t64);

+    t64 = creds->endtime;

+    header->endtime = htonll(t64);

+    t64 = creds->renew_till;

+    header->renew_till = htonll(t64);

+

+    header->is_skey = htonl(creds->is_skey);

+    header->ticket_flags = htonl(creds->ticket_flags);

+

+    cci_creds_cc_data_array_count_entries( creds->addresses, &count );

+    if ( count ) {

+        cc_flat_data * addresses = (cc_flat_data *)flat + offset;

+	header->address_count = htonl(count);

+        header->addresses = htonl(offset);

+        offset += count * sizeof(cc_flat_data);

+

+        for ( i=0; i < count; i++ ) {

+            addresses[i].type = htonl(creds->addresses[i]->type);

+            if (creds->addresses[i]->length) {

+		length = creds->addresses[i]->length;

+                addresses[i].length = htonl(length);

+                addresses[i].data = htonl(offset);

+		/* TODO: verify that addresses are stored in network order */

+                memcpy(flat + offset, creds->addresses[i]->data, length);

+                offset += length;

+            }

+        }

+    }

+

+    header->ticket.type = htonl(creds->ticket.type);

+    if (creds->ticket.length) {

+	length = creds->ticket.length;

+        header->ticket.length = htonl(length);

+        header->ticket.data = htonl(offset);

+        memcpy(flat + offset, creds->ticket.data, length);

+        offset += length;

+    }           

+

+    header->second_ticket.type = htonl(creds->second_ticket.type);

+    if (creds->second_ticket.length) {

+	length = creds->second_ticket.length;

+        header->second_ticket.length = htonl(length);

+        header->second_ticket.data = htonl(offset);

+        memcpy(flat + offset, creds->second_ticket.data, length);

+        offset += length;

+    }           

+

+    cci_creds_cc_data_array_count_entries( creds->authdata, &count );

+    if ( count ) {

+        cc_flat_data * authdata = (cc_flat_data *)flat + offset;

+

+	header->authdata_count = htonl(count);

+        header->authdata = (offset);

+        offset += count * sizeof(cc_flat_data);

+

+        for ( i=0; i < count; i++ ) {

+            authdata[i].type = htonl(creds->authdata[i]->type);

+            if (creds->authdata[i]->length) {

+		length = creds->authdata[i]->length;

+                authdata[i].length = htonl(length);

+                authdata[i].data = htonl(offset);

+                memcpy(flat + offset, creds->authdata[i]->data, length);

+                offset += length;

+            }

+        }

+    }

+

+    *pflat = flat;

+    *plen = len;

+    return ccNoError;

+}

+

+

+// TODO: a much better job of checking for out of memory errors

+//       and validating that we do not read beyond the flat input

+//       data buffer

+

+cc_int32

+cci_creds_v5_unmarshall( char * flat, 

+                         cc_uint32 len,

+                         cc_credentials_union * creds_union)

+{

+    struct cci_flat_creds_v5 * header;

+    cc_credentials_v5_t * creds;

+    cc_flat_data * flat_data;

+    cc_time64 t64;

+    cc_uint32  length;

+    cc_uint32  count;

+    cc_uint32  i;

+    cc_int32   code;

+

+    if ( flat == NULL || len == 0 || creds_union == NULL )

+        return ccErrBadParam;

+

+    creds_union->version = cc_credentials_v5;

+

+    header = (struct cci_flat_creds_v5 *)flat;

+

+    if ( ntohl(header->version) != FLAT_CREDS_V5_VERSION )

+        return ccErrBadParam;

+

+    creds = (cc_credentials_v5_t *)malloc(sizeof(cc_credentials_v5_t));

+    if ( creds == NULL )

+        return ccErrNoMem;

+    memset(creds, 0, sizeof(cc_credentials_v5_t));

+

+    if ( header->client.length ) {

+	length = ntohl(header->client.length);

+        creds->client = (char *)malloc(length);

+        memcpy(creds->client, flat + header->client.data, length);

+    }

+

+    if ( header->server.length ) {

+	length = ntohl(header->server.length);

+        creds->server = (char *)malloc(length);

+        memcpy(creds->server, flat + header->server.data, length);

+    }

+

+    creds->keyblock.type = ntohl(header->keyblock.type);

+    if ( header->keyblock.length ) {

+	length = ntohl(header->keyblock.length);

+        creds->keyblock.length = length;

+        creds->keyblock.data = malloc(length);

+        memcpy(creds->keyblock.data, flat + header->keyblock.data, length);

+    }

+

+    /* TODO: need to perform overflow validation checks to ensure

+     * that we do not attempt to store too large a value into cc_time_t

+     * when it is a 32-bit field.

+     */

+    t64 = ntohll(header->authtime);

+    creds->authtime = (cc_time)t64;

+    t64 = ntohll(header->starttime);

+    creds->starttime = (cc_time)t64;

+    t64 = ntohll(header->endtime);

+    creds->endtime = (cc_time)t64;

+    t64 = ntohll(header->renew_till);

+    creds->renew_till = (cc_time)t64;

+

+    creds->is_skey = ntohl(header->is_skey);

+    creds->ticket_flags = ntohl(header->ticket_flags);

+

+    count = ntohl(header->address_count);

+    creds->addresses = (cc_data **) malloc((count + 1) * sizeof(cc_data *));

+    flat_data = (cc_flat_data *)flat + header->addresses;

+    for ( i=0 ; i < count ; i++ ) {

+        creds->addresses[i] = (cc_data *)malloc(sizeof(cc_data));

+        creds->addresses[i]->type = ntohl(flat_data[i].type);

+	length = ntohl(flat_data[i].length);

+        creds->addresses[i]->length = length;

+        if ( length ) {

+            creds->addresses[i]->data = malloc(length);

+	    /* TODO: verify that addresses are stored in network order */

+            memcpy(creds->addresses[i]->data, flat + flat_data[i].data, length);

+        } else {

+            creds->addresses[i]->data = NULL;

+        }

+    }

+    creds->addresses[i] = NULL;

+

+    creds->ticket.type = ntohl(header->ticket.type);

+    length = ntohl(header->ticket.length);

+    if ( length ) {

+        creds->ticket.length = length;

+        creds->ticket.data = malloc(length);

+        memcpy(creds->ticket.data, flat + header->ticket.data, length);

+    }

+

+    creds->second_ticket.type = header->second_ticket.type;

+    if ( header->second_ticket.length ) {

+        creds->second_ticket.length = header->second_ticket.length;

+        creds->second_ticket.data = malloc(creds->second_ticket.length);

+        memcpy(creds->second_ticket.data, flat + header->second_ticket.data, creds->second_ticket.length);

+    }

+

+    count = ntohl(header->authdata_count);

+    creds->authdata = (cc_data **) malloc((count + 1) * sizeof(cc_data *));

+    flat_data = (cc_flat_data *)flat + header->authdata;

+    for ( i=0 ; i < count ; i++ ) {

+        creds->authdata[i] = (cc_data *)malloc(sizeof(cc_data));

+        creds->authdata[i]->type = ntohl(flat_data[i].type);

+	length = ntohl(flat_data[i].length);

+        creds->authdata[i]->length = length;

+        if ( length ) {

+            creds->authdata[i]->data = malloc(length);

+            memcpy(creds->authdata[i]->data, flat + flat_data[i].data, length);

+        } else {

+            creds->authdata[i]->data = NULL;

+        }

+    }

+    creds->authdata[i] = NULL;

+

+    creds_union->credentials.credentials_v5 = creds;

+

+    return ccNoError;

+}

+

diff --git a/src/lib/ccapi/client/msg.c b/src/lib/ccapi/client/msg.c
new file mode 100644
index 000000000..facaffffc
--- /dev/null
+++ b/src/lib/ccapi/client/msg.c
@@ -0,0 +1,628 @@
+/* $Copyright:

+ *

+ * Copyright 2004-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).

+ * $

+ */

+

+/*

+ * Verifiable, extensible message format.

+ *

+ * Format:

+ * <size of header block (header_len)>

+ * <size of *entire* message, including previous field (flat_len)>

+ * <message type (type)>

+ * <type specific header (header)>

+ * <magic number (magic)>

+ * <data blob 1 length>

+ * <data blob 1>

+ * <data blob 2 length>

+ * <data blob 2>

+ * ...

+ * <magic number (magic)>

+ *

+ * If the header has variable length data it is included in the data blobs. 

+ * The header field has the offset from the beginning of the message of the 1st 

+ * byte of the data and the length of the data.

+ */

+

+#include "CredentialsCache.h"

+#include "msg.h"

+#include "generic_lists.h"

+

+#include <stdlib.h>

+#include <memory.h>

+#include <stdio.h>

+#include <string.h>

+

+/**

+ * cci_msg_new()

+ *

+ * Purpose: Allocate and initialize a new cc_msg_t structure

+ *

+ * Input parameter (type) in host order

+ *

+ * Return:  non-NULL, the msg

+ *          NULL, failure

+ *

+ * Errors:  ccErrNoMem

+ *

+ */

+cc_int32

+cci_msg_new(cc_uint32 type, cc_msg_t** msgpp) 

+{

+    // type should be validated.  If invalid set error to ccErrBadParam

+    cc_msg_t* msg;

+    

+    if ( type > CC_MSG_MAX_TYPE || msgpp == NULL )

+        return ccErrBadParam;

+

+    msg = (cc_msg_t*)malloc(sizeof(cc_msg_t));

+    if (msg == NULL)

+        return ccErrNoMem;

+

+    msg->type = htonl(type);

+    msg->flat = NULL;

+    msg->header = NULL;

+    msg->flat_len = 0;

+    msg->header_len = 0;

+    msg->magic = 0;

+    cci_generic_list_new(&msg->data_blobs);

+    if (msg->data_blobs == NULL) {

+        // pass on error from previous call

+        free(msg);

+        return ccErrNoMem;

+    }

+

+    *msgpp = msg;     

+    return ccNoError;

+}

+

+/**

+ * cci_msg_calc_header_size()

+ *

+ * Purpose: Calculates the size of the header

+ *

+ * Return:  the size in bytes

+ *

+ * Errors:  ccErrBadParam

+ *

+ */

+cc_int32

+cci_msg_calc_header_size(cc_msg_t* msg, cc_uint32 * lenp) 

+{

+    int header_len = 12; /* header size, entire size, type */

+

+    if ( msg == NULL || lenp == NULL )

+        return ccErrBadParam;

+

+    header_len += msg->header_len;

+    *lenp = header_len;

+    return ccNoError;

+}

+

+/**

+ * cci_msg_calc_size()

+ *

+ * Purpose: Calculates the size of the message

+ *          (does not include the magic bytes)

+ *

+ * Return:  the size in bytes

+ *

+ * Errors:  ccErrBadParam

+ *

+ */

+cc_int32 

+cci_msg_calc_size(cc_msg_t* msg, cc_uint32 * lenp) 

+{

+    cc_uint32 flat_len;

+    cc_generic_list_node_t* gen_node;

+    cc_generic_iterate_t* gen_iterator;

+	cc_int32 code;

+

+    if ( msg == NULL || lenp == NULL ) 

+        return ccErrBadParam;

+

+    code = cci_msg_calc_header_size(msg, &flat_len);

+    if (code != ccNoError)

+        goto bad;

+

+    code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator);

+    if ( code != ccNoError )

+        goto bad;

+

+    while (cci_generic_iterate_has_next(gen_iterator)) {

+        code = cci_generic_iterate_next(gen_iterator, &gen_node);

+        if (code != ccNoError)

+            break;

+        flat_len += gen_node->len + BLOB_LEN;

+    }

+    cci_generic_free_iterator(gen_iterator);

+    if (code != ccNoError)

+        goto bad;

+

+    flat_len += MAGIC_HEAD_LEN + MAGIC_DATA_LEN;

+    *lenp = flat_len;

+

+  bad:

+    return code;

+}

+

+/**

+ * cci_msg_add_data_blob()

+ *

+ * Purpose: Adds 'len' bytes of data to the msg

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32 

+cci_msg_add_data_blob(cc_msg_t* msg, void *data, cc_uint32 len, cc_uint32 *lenp) 

+{

+    cc_int32 code;

+

+    if (msg == NULL || data == NULL || len <= 0 || lenp == NULL)

+        return ccErrBadParam;

+

+    code = cci_generic_list_append(msg->data_blobs, data, len, NULL);

+    if ( code != ccNoError )

+        return code;

+    return cci_msg_calc_blob_pos(msg, data, len, lenp);

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32 

+cci_msg_calc_blob_pos(cc_msg_t* msg, void *data, cc_uint32 len, cc_uint32 * posp) 

+{

+    cc_uint32 pos;

+    cc_generic_list_node_t* gen_node;

+    cc_generic_iterate_t* gen_iterator;

+    cc_int32 code;

+

+    code = cci_msg_calc_header_size(msg, &pos);

+    pos += sizeof(cc_uint32); /*+ sizeof(cc_uint32) for magic*/

+

+    code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator);

+    while (cci_generic_iterate_has_next(gen_iterator)) {

+        code = cci_generic_iterate_next(gen_iterator, &gen_node);

+        if (gen_node->len != len && gen_node->data != data) {

+            pos += gen_node->len + sizeof(cc_uint32);

+        } else {

+            cci_generic_free_iterator(gen_iterator);

+            *posp = pos + sizeof(cc_uint32);

+            return ccNoError;

+        }

+    }

+    

+    cci_generic_free_iterator(gen_iterator);

+    return ccIteratorEnd;

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32 

+cci_msg_add_header(cc_msg_t* msg, void *header, cc_uint32 header_len) 

+{

+    if ( msg == NULL || header == NULL )

+        return ccErrBadParam;

+

+    msg->header = header;

+    msg->header_len = header_len;

+    return ccNoError;

+}

+

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32

+cci_msg_flatten(cc_msg_t* msg, void **flatpp) 

+{

+    cc_generic_list_node_t* gen_node;

+    cc_generic_iterate_t* gen_iterator;

+    char *cur_pos;

+    cc_uint32 zero = 0;

+    cc_uint32 magic = 0;

+    cc_uint32 msg_len;

+    cc_uint32 u32;

+    cc_int32 code;

+

+    if (msg == NULL || flatpp == NULL)

+        return ccErrBadParam;

+

+    code = cci_msg_calc_size(msg,&msg->flat_len);

+    if ( code != ccNoError )

+        return code;

+

+    if (msg->flat_len > CC_MSG_MAX_SIZE)

+        return ccErrBadParam;

+

+    msg->flat = (void *)malloc(msg->flat_len);

+    if (msg->flat == NULL)

+        return ccErrNoMem;

+    

+    cur_pos = msg->flat;

+

+    u32 = msg->header_len;

+    htonl(u32);

+    memcpy(cur_pos,&u32,sizeof(cc_uint32));

+    cur_pos+=sizeof(cc_uint32);

+

+    u32 = msg->flat_len;

+    htonl(u32);

+    memcpy(cur_pos,&u32,sizeof(cc_uint32));

+    cur_pos+=sizeof(cc_uint32);

+

+    u32 = msg->type;

+    htonl(u32);

+    memcpy(cur_pos,&u32,sizeof(cc_uint32));

+    cur_pos+=sizeof(cc_uint32);

+

+    /* header data is already in network order */

+    memcpy(cur_pos, msg->header, msg->header_len);

+    cur_pos += msg->header_len;

+

+    u32 = zero;

+    htonl(zero);

+    memcpy(cur_pos, &u32, sizeof(cc_uint32)); /*will be magic number later*/

+    cur_pos += sizeof(cc_uint32);

+

+    code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator);

+    if ( code != ccNoError ) {

+        free(msg->flat);

+        return code;

+    }

+

+    while (cci_generic_iterate_has_next(gen_iterator)) {

+        code = cci_generic_iterate_next(gen_iterator, &gen_node);

+        if (code != ccNoError) {

+            free(gen_iterator);

+            free(msg->flat);

+            return code;

+        }

+	u32 = gen_node->len;

+	htonl(u32);

+        memcpy(cur_pos, &u32, sizeof(cc_uint32));

+        cur_pos+=sizeof(cc_uint32);

+		

+	/* data already in network order */

+        memcpy(cur_pos, gen_node->data, gen_node->len);

+        cur_pos += gen_node->len;

+    }

+    free(gen_iterator);

+

+    u32 = zero;

+    htonl(zero);

+    memcpy(cur_pos, &u32, sizeof(cc_uint32)); /*magic number will go here later*/

+    cur_pos += sizeof(cc_uint32);

+

+    if (cur_pos - (char *)msg->flat != msg->flat_len) {

+        fprintf(stderr, "ERROR cur_pos - msg->flat = %d\n",msg->flat_len);

+    }

+

+    cci_msg_calc_magic(msg->flat, msg->flat_len, &magic);

+    printf("magic = %d\n",magic);

+	

+    cci_msg_calc_header_size(msg, &msg_len);

+    memcpy((char *)msg->flat + msg_len, &magic, sizeof(cc_uint32));

+    memcpy((char *)msg->flat + msg->flat_len - sizeof(cc_uint32), &magic, sizeof(cc_uint32));

+

+    if ( flatpp != NULL )

+        *flatpp = msg->flat;

+

+    return ccNoError;

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32

+cci_msg_calc_magic(void *flat, int flat_len, cc_uint32 * magicp)

+{

+    cc_uint32 magic = 0;

+    int i;

+	

+    for (i = 0; i < flat_len; i += sizeof(cc_uint32)) {

+        magic = magic ^ *(int *)((char *)flat + i);

+    }

+    *magicp = htonl(magic);

+    return ccNoError;

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32 

+cci_msg_verify(void *flat, int flat_len, cc_uint32 * validp)  

+{

+    cc_uint32 *magic1, *magic2;

+    cc_uint32 *pheader_len;

+    cc_uint32 header_len;

+    cc_uint32 *ptotal_len;

+    cc_uint32 total_len;

+    cc_uint32 *pblob_len;

+    cc_uint32 blob_len;

+    cc_uint32 *ptype;

+    cc_uint32 type;

+    cc_uint32 num_blobs = 0;

+    cc_uint32 zero = 0;

+    cc_uint32 msg_magic, msg_magic2;

+

+    if (flat == NULL || flat_len <= 0 || validp == NULL)

+        return ccErrBadParam;

+

+    pheader_len = flat;

+    ptotal_len = (cc_uint32 *)((char *)pheader_len + sizeof(cc_uint32));

+    ptype = (cc_uint32 *)((char *)ptotal_len + sizeof(cc_uint32));

+

+    header_len = ntohl(*pheader_len);

+    total_len = ntohl(*ptotal_len);

+    type = ntohl(*ptype);

+

+    if (total_len != flat_len) {

+        *validp = 0;

+        return ccNoError;

+    }

+    

+    if (header_len > flat_len) {

+        /*too weak. We could verify header_len against type spec header.*/

+        *validp = 0;

+        return ccNoError;

+    }

+    if (type > CC_MSG_MAX_TYPE) {

+        *validp = 0;

+        return ccNoError;

+    }

+

+    magic1 = (cc_uint32 *)((char *)ptype + sizeof(cc_uint32) + header_len); 

+    if ((char *)magic1 - (char *)flat == (flat_len - 8)) {

+        /*There are no data blobs*/

+        magic2 = (cc_uint32 *)((char *)magic1 + sizeof(cc_uint32));

+        num_blobs = 0;

+    } else {

+        pblob_len = (cc_uint32 *)((char *)magic1 + sizeof(cc_uint32));

+        num_blobs = 1;

+	blob_len = nothl(*pblob_len);

+

+        while (blob_len + sizeof(cc_uint32) + ((char *)pblob_len - (char *)flat) < (flat_len - sizeof(cc_uint32))) {

+            pblob_len = (cc_uint32 *)((char *)pblob_len + blob_len + sizeof(cc_uint32));

+            num_blobs++;

+	    blob_len = ntohl(*pblob_len);

+        }

+

+        if (blob_len + sizeof(cc_uint32) + ((char *)pblob_len - (char *)flat) != (flat_len - sizeof(cc_uint32))) {

+            /*blobs didn't line up*/

+            *validp = 0;

+            return ccNoError;

+        }

+        magic2 = (cc_uint32 *)((char *)pblob_len + blob_len + sizeof(cc_uint32)); /*2nd magic should be directly after the last blob*/

+    }

+	

+    if (*magic1 != *magic2) {

+        *validp = 0;

+        return ccNoError;

+    }

+    msg_magic = *magic1;

+

+    printf("%d %d\n", (char *)magic1 - (char *)flat, (char *)magic2 - (char *)flat);

+

+    memcpy(magic1, &zero, sizeof(cc_uint32));

+    memcpy(magic2, &zero, sizeof(cc_uint32));

+    cci_msg_calc_magic(flat, flat_len, &msg_magic2);

+    /* both msg_magic and msg_magic2 are in network order */

+    if (msg_magic != msg_magic2) {

+        *validp = 0;

+        return ccNoError;

+    }

+    memcpy(magic1, &msg_magic, sizeof(cc_uint32));

+    memcpy(magic2, &msg_magic, sizeof(cc_uint32));

+

+    *validp = 1;

+    return ccNoError;

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32

+cci_msg_unflatten(void *flat, int flat_len, cc_msg_t** msgpp) 

+{

+    cc_msg_t* msg;

+    char *cur_pos;

+    cc_uint32 blob_len;

+    char *blob;

+    cc_uint32 valid;

+    cc_int32 code;

+

+    if ( flat == NULL || flat_len <= 0 || msgpp == NULL )

+        return ccErrBadParam;

+

+    code = cci_msg_new(0, &msg);

+    if (code)

+        return code;

+

+    cci_msg_verify(flat, flat_len, &valid);

+    if (valid != 1) {

+        cci_msg_destroy(msg);

+        return ccErrBadParam;

+    }

+

+    cur_pos = flat;

+    msg->flat = flat;

+

+    msg->header_len = ntohl(*(cc_uint32 *)cur_pos);

+    cur_pos += sizeof(cc_uint32);

+

+    msg->flat_len = ntohl(*(cc_uint32 *)cur_pos);

+    cur_pos += sizeof(cc_uint32);

+

+    msg->type = ntohl(*(cc_uint32 *)cur_pos);

+    cur_pos += sizeof(cc_uint32);

+

+    msg->header = (void *)malloc(msg->header_len);

+    if (msg->header == NULL) {

+        cci_msg_destroy(msg);

+        return ccErrNoMem;

+    }

+    memcpy(msg->header, cur_pos, msg->header_len);

+    cur_pos += msg->header_len;

+	

+    msg->magic = nothl(*(cc_uint32 *)cur_pos);

+    cur_pos += sizeof(cc_uint32);

+

+    if (cur_pos - (char *)flat != flat_len - 8) { /*at least 1 blob*/

+        blob_len = ntohl(*(cc_uint32 *)cur_pos);

+        while (blob_len + (cur_pos - (char *)flat) + sizeof(cc_uint32) <= flat_len - sizeof(cc_uint32)) {

+            blob = (void *)malloc(blob_len);

+            if (blob == NULL) {

+                cci_msg_destroy(msg);

+                return ccErrNoMem;

+            }

+            memcpy(blob, cur_pos + sizeof(cc_uint32), blob_len);

+            cci_generic_list_append(msg->data_blobs, blob, blob_len, NULL);

+

+            cur_pos += sizeof(cc_uint32) + blob_len;

+            blob_len = ntohl(*(int *)cur_pos);

+        }

+    }

+    *msgpp = msg;

+    return ccNoError;

+}

+

+cc_int32

+cci_msg_retrieve_blob(cc_msg_t* msg, cc_uint32 blob_offset, cc_uint32 blob_len, void **blobp) 

+{

+    cc_generic_iterate_t*	gen_iterator;

+    cc_generic_list_node_t*	gen_node;

+    void *ret;

+    cc_uint32                   blob_pos;

+    cc_int32                    code;

+

+    /*Ensure that the message has been unflattened*/

+    if ( msg == NULL || msg->flat == NULL || blob_offset > msg->flat_len || 

+         blob_len > msg->flat_len - blob_offset || blobp == NULL)

+        return ccErrBadParam;

+

+    code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator);

+    while (cci_generic_iterate_has_next(gen_iterator)) {

+        code = cci_generic_iterate_next(gen_iterator, &gen_node);

+        code = cci_msg_calc_blob_pos(msg, gen_node->data, gen_node->len, &blob_pos);

+        if (blob_pos == blob_offset && gen_node->len == blob_len)  {

+            free(gen_iterator);

+            ret = (void *)malloc(blob_len);

+            if (ret == NULL)

+                return ccErrNoMem;

+            memcpy(ret,(char *)msg->flat + blob_offset, blob_len);	

+            *blobp = ret;

+            return ccNoError;

+        }

+    }

+    free(gen_iterator);

+    return ccIteratorEnd;

+}

+

+/**

+ * cc_msg_

+ *

+ * Purpose:

+ *

+ * Return: 

+ *

+ * Errors: 

+ *

+ */

+cc_int32 

+cci_msg_destroy(cc_msg_t* msg) 

+{

+    if (msg->flat != NULL) 

+        free(msg->flat);

+    if (msg->header != NULL)

+        free(msg->flat);

+    cci_generic_list_destroy(msg->data_blobs);

+    free(msg);

+    return ccNoError;

+}

+