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

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

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

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

1 files changed, 420 insertions, 273 deletions

diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c
index 86c41b8e7..5d88d4686 100644
--- a/src/lib/ccapi/client/context.c
+++ b/src/lib/ccapi/client/context.c
@@ -1,6 +1,6 @@
 /* $Copyright:
  *
- * Copyright 2004 by the Massachusetts Institute of Technology.
+ * Copyright 2004-2006 by the Massachusetts Institute of Technology.
  * 
  * All rights reserved.
  * 
@@ -45,10 +45,20 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 #include <CredentialsCache.h>
 #include "context.h"
+#include "ccache.h"
+#include "ccache_iterator.h"
+#include "cc_rpc.h"
 #include "msg.h"
 #include "msg_headers.h"
+#include "ccstring.h"
+
+/* cc_int_context_new
+ *
+ * input parameters (handle, version) are in host order 
+ */
 
 cc_int32
 cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version )
@@ -87,11 +97,12 @@ cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version
 cc_int32    
 cc_int_context_release( cc_context_t context )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_release_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_release_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -104,28 +115,38 @@ cc_int_context_release( cc_context_t context )
     request_header = (ccmsg_ctx_release_t*)malloc(sizeof(ccmsg_ctx_release_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_RELEASE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_release_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	request_header = NULL;
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     free(int_context->functions);
     free(int_context);
     return code;
@@ -133,14 +154,16 @@ cc_int_context_release( cc_context_t context )
 
 cc_int32
 cc_int_context_get_change_time( cc_context_t context,
-                                cc_time_t* time)
+                                cc_time* time)
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_get_change_time_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 		int_context;
+    cc_msg_t        		*request = NULL;
+    ccmsg_ctx_get_change_time_t *request_header = NULL;
+    cc_msg_t        		*response = NULL;
     ccmsg_ctx_get_change_time_resp_t *response_header;
-    cc_int32 code;
+    cc_time64 		t64;
+    cc_uint32			type;
+    cc_int32 			code;
 
     if ( context == NULL || time == NULL )
         return ccErrBadParam;
@@ -153,30 +176,42 @@ cc_int_context_get_change_time( cc_context_t context,
     request_header = (ccmsg_ctx_get_change_time_t*)malloc(sizeof(ccmsg_ctx_get_change_time_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_GET_CHANGE_TIME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_change_time_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
     } else if (response->type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_get_change_time_resp_t*)response->header;
-        *time = response_header->time;
+        t64 = ntohll(response_header->time);
+	/* TODO: validate that value is not greater than can fit in cc_time */
+	*time = (cc_time)t64;
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -184,12 +219,14 @@ cc_int32
 cc_int_context_get_default_ccache_name( cc_context_t context,
                                         cc_string_t* name )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_get_default_ccache_name_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_get_default_ccache_name_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_get_default_ccache_name_resp_t *response_header;
-    cc_int32 code;
+    char 		*string = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL )
         return ccErrBadParam;
@@ -202,35 +239,44 @@ cc_int_context_get_default_ccache_name( cc_context_t context,
     request_header = (ccmsg_ctx_get_default_ccache_name_t*)malloc(sizeof(ccmsg_ctx_get_default_ccache_name_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_GET_DEFAULT_CCACHE_NAME, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_default_ccache_name_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
-        char * string;
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_get_default_ccache_name_resp_t*)response->header;
         code = cci_msg_retrieve_blob(response, response_header->name_offset, 
                                      response_header->name_len, &string);
-        if (code == ccNoError) {
-            code = cc_string_new(&name, string);
-            free(string);
-        }
+        if (code == ccNoError)
+            code = cci_string_new(name, string);
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (string)
+	free(string);
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -240,11 +286,12 @@ cc_int_context_compare( cc_context_t context,
                         cc_uint32* equal )
 {
     cc_int_context_t int_context, int_compare_to;
-    cc_msg_t        *request;
-    ccmsg_ctx_compare_t *request_header;
-    cc_msg_t        *response;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_compare_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_compare_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || compare_to == NULL || 
          equal == NULL )
@@ -260,31 +307,41 @@ cc_int_context_compare( cc_context_t context,
     request_header = (ccmsg_ctx_compare_t*)malloc(sizeof(ccmsg_ctx_compare_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx1 = int_context->handle;
-    request_header->ctx2 = int_compare_to->handle;
+    request_header->ctx1 = htonll(int_context->handle);
+    request_header->ctx2 = htonll(int_compare_to->handle);
 
     code = cci_msg_new(ccmsg_CTX_COMPARE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_compare_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_compare_resp_t*)response->header;
-        *equal = response_header->is_equal;
+        *equal = ntohl(response_header->is_equal);
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -293,12 +350,13 @@ cc_int32
 cc_int_context_new_ccache_iterator( cc_context_t context,
                                     cc_ccache_iterator_t* iterator )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_new_ccache_iterator_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_new_ccache_iterator_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ctx_new_ccache_iterator_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL || iterator == NULL )
         return ccErrBadParam;
@@ -311,29 +369,40 @@ cc_int_context_new_ccache_iterator( cc_context_t context,
     request_header = (ccmsg_ctx_new_ccache_iterator_t*)malloc(sizeof(ccmsg_ctx_new_ccache_iterator_t));
     if (request_header == NULL)
         return ccErrNoMem;
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_new(ccmsg_CTX_NEW_CCACHE_ITERATOR, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_new_ccache_iterator_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ctx_new_ccache_iterator_resp_t*)response->header;
-        code = cc_int_ccache_iterator_new(iterator, int_context->handle, response_header->iterator);
+        code = cc_int_ccache_iterator_new(iterator, int_context->handle,
+					   ntohll(response_header->iterator));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -342,13 +411,14 @@ cc_int_context_open_ccache( cc_context_t context,
                             const char* name,
                             cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_open_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_open_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_open_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL || ccache == NULL )
         return ccErrBadParam;
@@ -362,38 +432,45 @@ cc_int_context_open_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_OPEN, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->ctx = int_context->handle;
-    request_header->name_offset = blob_pos;
-    request_header->name_len = strlen(name) + 1;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->name_offset = htonl(blob_pos);
+    request_header->name_len = htonl(strlen(name) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_open_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -401,12 +478,13 @@ cc_int32
 cc_int_context_open_default_ccache( cc_context_t context,
                                     cc_ccache_t* ccache)
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_open_default_t *request_header;
-    cc_msg_t        *response;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_open_default_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_open_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || ccache == NULL )
         return ccErrBadParam;
@@ -420,29 +498,39 @@ cc_int_context_open_default_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_OPEN_DEFAULT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN_DEFAULT, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_default_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_open_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -453,13 +541,14 @@ cc_int_context_create_ccache( cc_context_t context,
                               const char* principal, 
                               cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || name == NULL || 
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -475,48 +564,53 @@ cc_int_context_create_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
     code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
     
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
-    request_header->name_offset = blob_pos;
-    request_header->name_len = strlen(name) + 1;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
+    request_header->name_offset = htonl(blob_pos);
+    request_header->name_len = htonl(strlen(name) + 1);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -526,13 +620,14 @@ cc_int_context_create_default_ccache( cc_context_t context,
                                       const char* principal, 
                                       cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_default_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_default_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL ||
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -548,39 +643,47 @@ cc_int_context_create_default_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE_DEFAULT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_DEFAULT, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_default_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response->header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -590,13 +693,14 @@ cc_int_context_create_new_ccache( cc_context_t context,
                                   const char* principal, 
                                   cc_ccache_t* ccache )
 {
-    cc_uint32 blob_pos;
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ccache_create_unique_t *request_header;
-    cc_msg_t        *response;
+    cc_uint32 		blob_pos;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ccache_create_unique_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
     ccmsg_ccache_create_resp_t *response_header;
-    cc_int32 code;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL ||
          cred_vers == 0 || cred_vers > cc_credentials_v4_v5 ||
@@ -612,39 +716,47 @@ cc_int_context_create_new_ccache( cc_context_t context,
     if (request_header == NULL)
         return ccErrNoMem;
 
-    code = cci_msg_new(ccmsg_CCACHE_CREATE_UNIQUE, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_UNIQUE, &request);
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->version = cred_vers;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->version = htonl(cred_vers);
 
     code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos);
-    if (code != ccNoError) {
-        cci_msg_destroy(request);
-        free(request_header);
-        return code;
-    }
-    request_header->principal_offset = blob_pos;
-    request_header->principal_len = strlen(principal) + 1;
+    if (code != ccNoError)
+	goto cleanup;
+
+    request_header->principal_offset = htonl(blob_pos);
+    request_header->principal_len = htonl(strlen(principal) + 1);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_unique_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = htonl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         response_header = (ccmsg_ccache_create_resp_t*)response-> header;
-        code = cc_cache_new(ccache, response_header->ccache);
+        code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache));
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
  
@@ -653,14 +765,16 @@ cc_int_context_lock( cc_context_t context,
                      cc_uint32 lock_type,
                      cc_uint32 block )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_lock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_lock_t 	*request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32		type;
+    cc_int32 		code;
 
     if ( context == NULL || 
-         (lock_type != cc_lock_read && lock_type != cc_lock_write) ||
+         (lock_type != cc_lock_read && lock_type != cc_lock_write &&
+	  lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) ||
          (block != cc_lock_block && block != cc_lock_noblock) )
         return ccErrBadParam;
 
@@ -674,41 +788,52 @@ cc_int_context_lock( cc_context_t context,
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CTX_LOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
-    request_header->lock_type;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->lock_type = htonl(lock_type);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_lock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
+        code = ntohl(nack_header->err_code);
 
         // TODO: if (block == cc_lock_block) .....
-    } else if (response->type == ccmsg_ACK) {
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
 cc_int32
 cc_int_context_unlock( cc_context_t context )
 {
-    cc_int_context_t int_context;
-    cc_msg_t        *request;
-    ccmsg_ctx_unlock_t *request_header;
-    cc_msg_t        *response;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    cc_msg_t        	*request = NULL;
+    ccmsg_ctx_unlock_t *request_header = NULL;
+    cc_msg_t        	*response = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( context == NULL )
         return ccErrBadParam;
@@ -723,27 +848,37 @@ cc_int_context_unlock( cc_context_t context )
         return ccErrNoMem;
 
     code = cci_msg_new(ccmsg_CTX_UNLOCK, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    request_header->ctx = int_context->handle;
+    request_header->ctx = htonll(int_context->handle);
 
     code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_unlock_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
         code = ccNoError;
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+
+  cleanup:
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -754,20 +889,22 @@ cc_int_context_clone( cc_context_t      inContext,
                       cc_int32*         supportedVersion,
                       char const**      vendor )
 {
-    cc_int_context_t int_context, new_context;
-    static char vendor_st[128] = "";
-    cc_msg_t     *request;
-    ccmsg_clone_t *request_header;
-    cc_msg_t     *response;
-    ccmsg_clone_resp_t *response_header;
-    cc_int32 code;
+    cc_int_context_t 	int_context;
+    static char 	vendor_st[128] = "";
+    cc_msg_t     	*request = NULL;
+    ccmsg_ctx_clone_t 	*request_header = NULL;
+    cc_msg_t     	*response = NULL;
+    ccmsg_ctx_clone_resp_t *response_header;
+    char 		*string = NULL;
+    cc_uint32 		type;
+    cc_int32 		code;
 
     if ( inContext == NULL ||
          outContext == NULL ||
          supportedVersion == NULL )
         return ccErrBadParam;
 
-    int_context = (cc_int_context_t)context;
+    int_context = (cc_int_context_t)inContext;
 
     if ( int_context->magic != CC_CONTEXT_MAGIC )
         return ccErrInvalidContext;
@@ -775,45 +912,48 @@ cc_int_context_clone( cc_context_t      inContext,
     if ((requestedVersion != ccapi_version_2) &&
          (requestedVersion != ccapi_version_3) &&
          (requestedVersion != ccapi_version_4) &&
-         (requestedVersion != ccapi_version_5)) {
+         (requestedVersion != ccapi_version_5) &&
+	 (requestedVersion != ccapi_version_6)) {
 
         if (supportedVersion != NULL) {
-            *supportedVersion = ccapi_version_5;
+            *supportedVersion = ccapi_version_max;
         }
         return ccErrBadAPIVersion;
     }   
 
-    request_header = (ccmsg_clone_t*)malloc(sizeof(ccmsg_clone_t));
+    request_header = (ccmsg_ctx_clone_t*)malloc(sizeof(ccmsg_ctx_clone_t));
     if (request_header == NULL)
         return ccErrNoMem;
 
-    request_header->ctx = int_context->handle;
-    request_header->in_version = requestedVersion;
+    request_header->ctx = htonll(int_context->handle);
+    request_header->in_version = htonl(requestedVersion);
 
     code = cci_msg_new(ccmsg_INIT, &request);
-    if (code != ccNoError) {
-        free(request_header);
-        return code;
-    }
+    if (code != ccNoError)
+	goto cleanup;
 
-    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_init_t));
+    code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_clone_t));
+    if (code != ccNoError)
+	goto cleanup;
+    request_header = NULL;
 
     code = cci_perform_rpc(request, &response);
+    if (code != ccNoError)
+	goto cleanup;
 
-    if (response->type == ccmsg_NACK) {
+    type = ntohl(response->type);
+    if (type == ccmsg_NACK) {
         ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header;
-        code = nack_header->err_code;
-    } else if (response->type == ccmsg_ACK) {
-        response_header = (ccmsg_clone_resp_t *)response->header;
-        *supportedVersion = response_header->out_version;
-        code = cc_int_context_new(outContext, response_header->out_ctx, response_header->out_version);
+        code = ntohl(nack_header->err_code);
+    } else if (type == ccmsg_ACK) {
+        response_header = (ccmsg_ctx_clone_resp_t *)response->header;
+        *supportedVersion = ntohl(response_header->out_version);
+        code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version));
 
         if (!vendor_st[0]) {
-            char * string;
-            code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string);
+            code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string);
             strncpy(vendor_st, string, sizeof(vendor_st)-1);
             vendor_st[sizeof(vendor_st)-1] = '\0';
-            free(string);
         } 
         *vendor = vendor_st;
 
@@ -821,8 +961,16 @@ cc_int_context_clone( cc_context_t      inContext,
     } else {
         code = ccErrBadInternalMessage;
     }
-    cci_msg_destroy(request);
-    cci_msg_destroy(response);
+    
+  cleanup:
+    if (string)
+	free(string);
+    if (request_header)
+	free(request_header);
+    if (request)
+	cci_msg_destroy(request);
+    if (response)
+	cci_msg_destroy(response);
     return code;
 }
 
@@ -831,7 +979,6 @@ cc_int_context_get_version( cc_context_t        context,
                             cc_int32*           version )
 {
     cc_int_context_t int_context;
-    cc_int32 code;
 
     if ( context == NULL ||
          version == NULL )