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, 347 insertions, 261 deletions

diff --git a/src/lib/ccapi/server/serv_ops.c b/src/lib/ccapi/server/serv_ops.c
index 30a108a34..52c62f45c 100644
--- a/src/lib/ccapi/server/serv_ops.c
+++ b/src/lib/ccapi/server/serv_ops.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.
  * 
@@ -50,6 +50,7 @@
 #include "datastore.h"
 #include "rpc_auth.h"
 #include "msg_headers.h"
+#include "marshall.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -62,33 +63,39 @@ extern int cc_myversion;
 extern char cc_vendor[];
 
 cc_int32 
-cci_serv_initialize(void) 
+ccs_serv_initialize(void) 
 {
     cc_int32 code;
 
-    code = cci_context_list_new(&AllContexts);
+    code = ccs_context_list_new(&AllContexts);
     if ( code != ccNoError )
         return code;
     TypeToOpMapping = (type_to_op_mapping_t*)malloc(sizeof(type_to_op_mapping_t));
     if (TypeToOpMapping == NULL) {
-        cci_context_list_destroy(AllContexts);
+        ccs_context_list_destroy(AllContexts);
         return ccErrNoMem;
     }
 
+#if 0
+    /* These message types are only generated by the server in response
+     * to a request.  They are never received.
+     */
+    TypeToOpMapping->operations[ccmsg_ACK] = ccop_ACK;
+    TypeToOpMapping->operations[ccmsg_NACK] = ccop_NACK;
+#endif
     TypeToOpMapping->operations[ccmsg_INIT] = ccop_INIT;
     TypeToOpMapping->operations[ccmsg_CTX_RELEASE] = ccop_CTX_RELEASE;
     TypeToOpMapping->operations[ccmsg_CTX_GET_CHANGE_TIME] = ccop_CTX_GET_CHANGE_TIME;
     TypeToOpMapping->operations[ccmsg_CTX_GET_DEFAULT_CCACHE_NAME] = ccop_CTX_GET_DEFAULT_CCACHE_NAME;
-    TypeToOpMapping->operations[ccmsg_CTX_COMPARE] = ccop_CTX_COMPARE;
+    TypeToOpMapping->operations[ccmsg_CTX_CCACHE_OPEN] = ccop_CTX_CCACHE_OPEN;
+    TypeToOpMapping->operations[ccmsg_CTX_CCACHE_OPEN_DEFAULT] = ccop_CTX_CCACHE_OPEN_DEFAULT;
+    TypeToOpMapping->operations[ccmsg_CTX_CCACHE_CREATE] = ccop_CTX_CCACHE_CREATE;
+    TypeToOpMapping->operations[ccmsg_CTX_CCACHE_CREATE_DEFAULT] = ccop_CTX_CCACHE_CREATE_DEFAULT;
+    TypeToOpMapping->operations[ccmsg_CTX_CCACHE_CREATE_UNIQUE] = ccop_CTX_CCACHE_CREATE_UNIQUE;
     TypeToOpMapping->operations[ccmsg_CTX_NEW_CCACHE_ITERATOR] = ccop_CTX_NEW_CCACHE_ITERATOR;
     TypeToOpMapping->operations[ccmsg_CTX_LOCK] = ccop_CTX_LOCK;
     TypeToOpMapping->operations[ccmsg_CTX_UNLOCK] = ccop_CTX_UNLOCK;
-    TypeToOpMapping->operations[ccmsg_CTX_CLONE] = ccop_CTX_CLONE;
-    TypeToOpMapping->operations[ccmsg_CCACHE_OPEN] = ccop_CCACHE_OPEN;
-    TypeToOpMapping->operations[ccmsg_CCACHE_OPEN_DEFAULT] = ccop_CCACHE_OPEN_DEFAULT;
-    TypeToOpMapping->operations[ccmsg_CCACHE_CREATE] = ccop_CCACHE_CREATE;
-    TypeToOpMapping->operations[ccmsg_CCACHE_CREATE_DEFAULT] = ccop_CCACHE_CREATE_DEFAULT;
-    TypeToOpMapping->operations[ccmsg_CCACHE_CREATE_UNIQUE] = ccop_CCACHE_CREATE_UNIQUE;
+    TypeToOpMapping->operations[ccmsg_CTX_COMPARE] = ccop_CTX_COMPARE;
     TypeToOpMapping->operations[ccmsg_CCACHE_RELEASE] = ccop_CCACHE_RELEASE;
     TypeToOpMapping->operations[ccmsg_CCACHE_DESTROY] = ccop_CCACHE_DESTROY;
     TypeToOpMapping->operations[ccmsg_CCACHE_SET_DEFAULT] = ccop_CCACHE_SET_DEFAULT;
@@ -96,9 +103,12 @@ cci_serv_initialize(void)
     TypeToOpMapping->operations[ccmsg_CCACHE_GET_NAME] = ccop_CCACHE_GET_NAME;
     TypeToOpMapping->operations[ccmsg_CCACHE_GET_PRINCIPAL] = ccop_CCACHE_GET_PRINCIPAL;
     TypeToOpMapping->operations[ccmsg_CCACHE_SET_PRINCIPAL] = ccop_CCACHE_SET_PRINCIPAL;
-    TypeToOpMapping->operations[ccmsg_CCACHE_CREDS_ITERATOR] = ccop_CCACHE_CREDS_ITERATOR;
+    TypeToOpMapping->operations[ccmsg_CCACHE_NEW_CREDS_ITERATOR] = ccop_CCACHE_NEW_CREDS_ITERATOR;
     TypeToOpMapping->operations[ccmsg_CCACHE_STORE_CREDS] = ccop_CCACHE_STORE_CREDS;
     TypeToOpMapping->operations[ccmsg_CCACHE_REM_CREDS] = ccop_CCACHE_REM_CREDS;
+    TypeToOpMapping->operations[ccmsg_CCACHE_MOVE] = ccop_CCACHE_MOVE;
+    TypeToOpMapping->operations[ccmsg_CCACHE_LOCK] = ccop_CCACHE_LOCK;
+    TypeToOpMapping->operations[ccmsg_CCACHE_UNLOCK] = ccop_CCACHE_UNLOCK;
     TypeToOpMapping->operations[ccmsg_CCACHE_GET_LAST_DEFAULT_TIME] = ccop_CCACHE_GET_LAST_DEFAULT_TIME;
     TypeToOpMapping->operations[ccmsg_CCACHE_GET_CHANGE_TIME] = ccop_CCACHE_GET_CHANGE_TIME;
     TypeToOpMapping->operations[ccmsg_CCACHE_COMPARE] = ccop_CCACHE_COMPARE;
@@ -107,48 +117,61 @@ cci_serv_initialize(void)
     TypeToOpMapping->operations[ccmsg_CCACHE_CLEAR_KDC_TIME_OFFSET] = ccop_CCACHE_CLEAR_KDC_TIME_OFFSET;
     TypeToOpMapping->operations[ccmsg_CCACHE_ITERATOR_RELEASE] = ccop_CCACHE_ITERATOR_RELEASE;
     TypeToOpMapping->operations[ccmsg_CCACHE_ITERATOR_NEXT] = ccop_CCACHE_ITERATOR_NEXT;
+    TypeToOpMapping->operations[ccmsg_CCACHE_ITERATOR_CLONE] = ccop_CCACHE_ITERATOR_CLONE;
     TypeToOpMapping->operations[ccmsg_CREDS_ITERATOR_RELEASE] = ccop_CREDS_ITERATOR_RELEASE;
     TypeToOpMapping->operations[ccmsg_CREDS_ITERATOR_NEXT] = ccop_CREDS_ITERATOR_NEXT;
-    TypeToOpMapping->operations[ccmsg_CREDS_RELEASE] = ccop_CREDS_RELEASE;
+    TypeToOpMapping->operations[ccmsg_CREDS_ITERATOR_CLONE] = ccop_CREDS_ITERATOR_CLONE;
 
     return ccNoError;
 };
 
 cc_int32 
-cci_serv_process_msg(cc_msg_t * msg, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
+ccs_serv_cleanup(void) 
+{
+    return ccNoError;
+}
+
+cc_int32 
+ccs_serv_process_msg(cc_msg_t * msg, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
 {
     cc_server_context_t* ctx;
     ccmsg_ctx_only_t* header = (ccmsg_ctx_only_t *)msg->header;
+    cc_uint32 type;
+    cc_uint32 header_len;
+    cc_handle handle; 
     cc_int32 code;
 
     if (msg == NULL || msg->header == NULL || auth_info == NULL || session_info == NULL)
         return ccErrBadParam;
 
     if (AllContexts == NULL) {
-        code = cci_serv_initialize();
+        code = ccs_serv_initialize();
         if ( code != ccNoError )
             return code;
     }
 	
-    if (msg->type == ccmsg_INIT) {
-        return TypeToOpMapping->operations[msg->type] (NULL, auth_info, session_info, msg, resp_msg);
+    type = msg->type;
+    if (type == ccmsg_INIT) {
+        return TypeToOpMapping->operations[type] (NULL, auth_info, session_info, msg, resp_msg);
     } else {
-        if (msg->header_len < sizeof(ccmsg_ctx_only_t)) {
+	header_len = msg->header_len;
+        if (header_len < sizeof(ccmsg_ctx_only_t)) {
             return ccErrBadParam;
         }
 
-        code = cci_serv_find_ctx_by_handle(header->ctx, auth_info, session_info, &ctx);
+	handle = ntohll(header->ctx);
+        code = ccs_serv_find_ctx_by_handle(handle, auth_info, session_info, &ctx);
         if (code != ccNoError) {
-            cci_serv_make_nack(ccErrContextNotFound, auth_info, session_info, resp_msg);
+            ccs_serv_make_nack(ccErrContextNotFound, auth_info, session_info, resp_msg);
             return code;
         }
-        return TypeToOpMapping->operations[msg->type] (ctx, auth_info, session_info, msg, resp_msg);
+        return TypeToOpMapping->operations[type] (ctx, auth_info, session_info, msg, resp_msg);
     }
 }
 
 /*deprecated*/
 cc_int32
-cci_serv_find_ctx(cc_auth_info_t* auth_info, cc_session_info_t* session_info,
+ccs_serv_find_ctx(cc_auth_info_t* auth_info, cc_session_info_t* session_info,
                   cc_server_context_t** ctxpp)
 {
     cc_context_iterate_t* ctx_iterator;
@@ -157,35 +180,35 @@ cci_serv_find_ctx(cc_auth_info_t* auth_info, cc_session_info_t* session_info,
     cc_int32 code;
     cc_uint32 authorized;
 
-    code = cci_context_list_iterator(AllContexts, &ctx_iterator);
+    code = ccs_context_list_iterator(AllContexts, &ctx_iterator);
     if (code != ccNoError)
         return code;
 
-    while (cci_context_iterate_has_next(ctx_iterator)) {
-        code = cci_context_iterate_next(ctx_iterator, &ctx_node);
+    while (ccs_context_iterate_has_next(ctx_iterator)) {
+        code = ccs_context_iterate_next(ctx_iterator, &ctx_node);
         if (code != ccNoError) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             return code;
         }
         ctx = (cc_server_context_t *)ctx_node->data;
-        code = cci_rpc_is_authorized(auth_info, session_info, ctx->auth_info, ctx->session_info, &authorized);
+        code = ccs_rpc_is_authorized(auth_info, session_info, ctx->auth_info, ctx->session_info, &authorized);
         if (code != ccNoError) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             return code;
         }
 
         if (authorized) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             *ctxpp = ctx;
             return ccNoError;
         }
     }
-    cci_context_free_iterator(ctx_iterator);
+    ccs_context_free_iterator(ctx_iterator);
     return ccIteratorEnd;
 }
 
 cc_int32
-cci_serv_find_ctx_by_handle(cc_handle ctx_num, cc_auth_info_t* auth, cc_session_info_t* session, cc_server_context_t** ctxpp) 
+ccs_serv_find_ctx_by_handle(cc_handle ctx_num, cc_auth_info_t* auth, cc_session_info_t* session, cc_server_context_t** ctxpp) 
 {
     cc_server_context_t* input_ctx = (cc_server_context_t*)ctx_num;
     cc_context_iterate_t* ctx_iterator;
@@ -194,36 +217,36 @@ cci_serv_find_ctx_by_handle(cc_handle ctx_num, cc_auth_info_t* auth, cc_session_
     cc_uint32 authorized;
     cc_int32 code;
 
-    code = cci_context_list_iterator(AllContexts, &ctx_iterator);
+    code = ccs_context_list_iterator(AllContexts, &ctx_iterator);
     if (code != ccNoError)
         return code;
 
-    while (cci_context_iterate_has_next(ctx_iterator)) {
-        code = cci_context_iterate_next(ctx_iterator, &ctx_node);
+    while (ccs_context_iterate_has_next(ctx_iterator)) {
+        code = ccs_context_iterate_next(ctx_iterator, &ctx_node);
         ctx = (cc_server_context_t *)ctx_node->data;
         if (code != ccNoError) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             return code;
         }
 
-        code = cci_rpc_is_authorized(auth, session, ctx->auth_info, ctx->session_info, &authorized);
+        code = ccs_rpc_is_authorized(auth, session, ctx->auth_info, ctx->session_info, &authorized);
         if (code != ccNoError) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             return code;
         }
 
         if (ctx == input_ctx && authorized) {
-            cci_context_free_iterator(ctx_iterator);
+            ccs_context_free_iterator(ctx_iterator);
             *ctxpp = ctx;
             return ccNoError;
         }
     }
-    cci_context_free_iterator(ctx_iterator);
+    ccs_context_free_iterator(ctx_iterator);
     return ccIteratorEnd;
 }
 
 cc_int32
-cci_serv_find_ccache_by_handle(cc_server_context_t* ctx, cc_handle ccache, cc_server_ccache_t** ccachepp ) 
+ccs_serv_find_ccache_by_handle(cc_server_context_t* ctx, cc_handle ccache, cc_server_ccache_t** ccachepp ) 
 {
     cc_ccache_iterate_t* ccache_iterator;
     cc_ccache_list_node_t* ccache_node;
@@ -231,31 +254,31 @@ cci_serv_find_ccache_by_handle(cc_server_context_t* ctx, cc_handle ccache, cc_se
     cc_server_ccache_t* target_ccache = (cc_server_ccache_t*)ccache;
     cc_int32 code;
 
-    code = cci_ccache_list_iterator(ctx->ccaches, &ccache_iterator);
+    code = ccs_ccache_list_iterator(ctx->ccaches, &ccache_iterator);
     if (code != ccNoError)
         return code;
 
-    while (cci_ccache_iterate_has_next(ccache_iterator)) {
-        code = cci_ccache_iterate_next(ccache_iterator, &ccache_node);
+    while (ccs_ccache_iterate_has_next(ccache_iterator)) {
+        code = ccs_ccache_iterate_next(ccache_iterator, &ccache_node);
         if (code != ccNoError) {
-            cci_ccache_free_iterator(ccache_iterator);
+            ccs_ccache_free_iterator(ccache_iterator);
             return code;
         }
 
         stored_ccache = (cc_server_ccache_t *)ccache_node->data;
 	
         if (stored_ccache == target_ccache) {
-            cci_ccache_free_iterator(ccache_iterator);
+            ccs_ccache_free_iterator(ccache_iterator);
             *ccachepp = stored_ccache;
             return ccNoError;
         }
     }
-    cci_ccache_free_iterator(ccache_iterator);
+    ccs_ccache_free_iterator(ccache_iterator);
     return ccIteratorEnd;
 }
 
 cc_int32
-cci_serv_find_ccache_iterator_by_handle(cc_server_context_t* ctx, cc_handle iterator, cc_generic_list_node_t** nodepp ) 
+ccs_serv_find_ccache_iterator_by_handle(cc_server_context_t* ctx, cc_handle iterator, cc_generic_list_node_t** nodepp ) 
 {
     cc_generic_iterate_t* gen_iterator;
     cc_generic_list_node_t* gen_node;
@@ -286,7 +309,7 @@ cci_serv_find_ccache_iterator_by_handle(cc_server_context_t* ctx, cc_handle iter
 }
 
 cc_int32
-cci_serv_find_creds_iterator_by_handle(cc_server_ccache_t* ccache, cc_handle iterator, cc_generic_list_node_t** nodepp) 
+ccs_serv_find_creds_iterator_by_handle(cc_server_ccache_t* ccache, cc_handle iterator, cc_generic_list_node_t** nodepp) 
 {
     cc_generic_iterate_t* gen_iterator;
     cc_generic_list_node_t* gen_node;
@@ -317,7 +340,7 @@ cci_serv_find_creds_iterator_by_handle(cc_server_ccache_t* ccache, cc_handle ite
 }       
 
 cc_int32 
-cci_serv_make_nack(cc_int32 err_code, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
+ccs_serv_make_nack(cc_int32 err_code, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
 {
     ccmsg_nack_t* nack_header;
     cc_int32 code;
@@ -333,7 +356,7 @@ cci_serv_make_nack(cc_int32 err_code, cc_auth_info_t* auth_info, cc_session_info
         return ccErrNoMem;
     }
 
-    nack_header->err_code = err_code;;
+    nack_header->err_code = htonl(err_code);
     code = cci_msg_add_header(*resp_msg, nack_header, sizeof(ccmsg_nack_t));
     if (code != ccNoError) {
         cci_msg_destroy(*resp_msg);
@@ -345,7 +368,7 @@ cci_serv_make_nack(cc_int32 err_code, cc_auth_info_t* auth_info, cc_session_info
 }
 
 cc_int32 
-cci_serv_make_ack(void * header, cc_int32 header_len, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
+ccs_serv_make_ack(void * header, cc_int32 header_len, cc_auth_info_t* auth_info, cc_session_info_t* session_info, cc_msg_t** resp_msg) 
 {
     cc_int32 code;
 
@@ -375,54 +398,58 @@ ccop_INIT( cc_server_context_t* ctx,            /* not used */
     ccmsg_init_resp_t *resp_header;
     ccmsg_init_t *header = (ccmsg_init_t *)msg->header;
     cc_context_list_node_t* ctx_node;
+    cc_uint32 header_len, in_version;
+
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_init_t)) {
+    header_len = msg->header_len;
+    if (ctx != NULL || header_len != sizeof(ccmsg_init_t)) {
         return ccErrBadParam;
     }
 
-    code = cci_context_new(header->in_version, auth_info, session_info, &new_ctx);
+    in_version = ntohl(header->in_version);
+    code = ccs_context_new(in_version, auth_info, session_info, &new_ctx);
     if (code != ccNoError) {
         return code;
     }
 
-    code = cci_context_list_append(AllContexts, ctx, &ctx_node);
+    code = ccs_context_list_append(AllContexts, new_ctx, &ctx_node);
     if (code != ccNoError) {
-        cci_context_destroy(new_ctx);
+        ccs_context_destroy(new_ctx);
         return code;
     }
 
     resp_header = (ccmsg_init_resp_t*)malloc(sizeof(ccmsg_init_resp_t));
     if (resp_header == NULL) {
-        cci_context_destroy(new_ctx);
+        ccs_context_destroy(new_ctx);
         return ccErrNoMem;
     }
 
     code = cci_msg_new(ccmsg_ACK, resp_msg);
     if (code != ccNoError) {
         free(resp_header);
-        cci_context_destroy(new_ctx);
+        ccs_context_destroy(new_ctx);
         return code;
     }
     code = cci_msg_add_data_blob(*resp_msg, cc_vendor, strlen(cc_vendor) + 1, &blob_pos);
     if (code != ccNoError) {
         free(resp_header);
-        cci_context_destroy(new_ctx);
+        ccs_context_destroy(new_ctx);
         cci_msg_destroy(*resp_msg);
         *resp_msg = 0;
         return code;
     }
 
-    resp_header->out_ctx = new_ctx;
-    resp_header->out_version = cc_myversion;
-    resp_header->vendor_offset = blob_pos;
-    resp_header->vendor_length = strlen(cc_vendor) + 1;
+    resp_header->out_ctx = htonll((cc_handle) new_ctx);
+    resp_header->out_version = htonl(cc_myversion);
+    resp_header->vendor_offset = htonl(blob_pos);
+    resp_header->vendor_length = htonl(strlen(cc_vendor) + 1);
     code = cci_msg_add_header(*resp_msg, resp_header, sizeof(ccmsg_init_resp_t));
     if (code != ccNoError) {
         free(resp_header);
-        cci_context_destroy(new_ctx);
+        ccs_context_destroy(new_ctx);
         cci_msg_destroy(*resp_msg);
         *resp_msg = 0;
         return code;
@@ -438,16 +465,18 @@ ccop_CTX_RELEASE( cc_server_context_t* ctx,
                   cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     ccmsg_ctx_release_t* header = (ccmsg_ctx_release_t *)msg->header;
+    cc_uint32 header_len = msg->header_len;
+    cc_handle handle = ntohll(header->ctx);
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ctx_release_t)) {
+    if (header_len != sizeof(ccmsg_ctx_release_t)) {
         return ccErrBadParam;
     }
 
-    code = cci_context_destroy(header->ctx);
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    code = ccs_context_destroy((cc_server_context_t *)handle);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -458,10 +487,11 @@ ccop_CTX_GET_CHANGE_TIME( cc_server_context_t* ctx,
 {
     ccmsg_ctx_get_change_time_resp_t* resp_header;
     ccmsg_ctx_get_change_time_t *header = (ccmsg_ctx_get_change_time_t *)msg->header;
+    cc_uint32 header_len = msg->header_len;
 
     *resp_msg = 0;
 	
-    if (msg->header_len != sizeof(ccmsg_ctx_get_change_time_t)) {
+    if (header_len != sizeof(ccmsg_ctx_get_change_time_t)) {
         return ccErrBadParam;
     }
 
@@ -470,8 +500,8 @@ ccop_CTX_GET_CHANGE_TIME( cc_server_context_t* ctx,
         return ccErrNoMem;
     }
 
-    resp_header->time = ctx->changed;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ctx_get_change_time_resp_t), auth_info, session_info, resp_msg);
+    resp_header->time = htonll(ctx->changed);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ctx_get_change_time_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -483,15 +513,16 @@ ccop_CTX_GET_DEFAULT_CCACHE_NAME( cc_server_context_t* ctx,
     char * name;
     ccmsg_ctx_get_default_ccache_name_resp_t* resp_header;
     ccmsg_ctx_get_default_ccache_name_t* header = (ccmsg_ctx_get_default_ccache_name_t *)msg->header;
+    cc_uint32 header_len = htonl(msg->header_len);
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ctx_get_default_ccache_name_t)) {
+    if (header_len != sizeof(ccmsg_ctx_get_default_ccache_name_t)) {
         return ccErrBadParam;
     }
 	
-    code = cci_context_get_default_ccache_name(ctx, &name);
+    code = ccs_context_get_default_ccache_name(ctx, &name);
     if (code != ccNoError)
         return code;
 
@@ -507,7 +538,7 @@ ccop_CTX_GET_DEFAULT_CCACHE_NAME( cc_server_context_t* ctx,
     }
 
     code = cci_msg_add_data_blob(*resp_msg, name, strlen(name) + 1, &resp_header->name_offset);
-    resp_header->name_len = strlen(name) + 1;
+    resp_header->name_len = htonl(strlen(name) + 1);
     return ccNoError;
 }
 
@@ -520,21 +551,22 @@ ccop_CTX_COMPARE(cc_server_context_t* ctx,
     cc_server_context_t *ctx2;
     ccmsg_ctx_compare_resp_t* resp_header;
     ccmsg_ctx_compare_t* header = (ccmsg_ctx_compare_t *)msg->header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ctx_compare_t))
+    if (header_len != sizeof(ccmsg_ctx_compare_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ctx_by_handle(header->ctx2, auth_info, session_info, &ctx2);
+    code = ccs_serv_find_ctx_by_handle(header->ctx2, auth_info, session_info, &ctx2);
 
     resp_header = (ccmsg_ctx_compare_resp_t*)malloc(sizeof(ccmsg_ctx_compare_resp_t));
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->is_equal = cci_context_compare(ctx, ctx2);
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ctx_compare_resp_t), auth_info, session_info, resp_msg);
+    resp_header->is_equal = htonl(ccs_context_compare(ctx, ctx2));
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ctx_compare_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -546,22 +578,23 @@ ccop_CTX_NEW_CCACHE_ITERATOR(cc_server_context_t* ctx,
     cc_ccache_iterate_t* ccache_iterator;
     ccmsg_ctx_new_ccache_iterator_resp_t* resp_header;
     ccmsg_ctx_new_ccache_iterator_t* header = (ccmsg_ctx_new_ccache_iterator_t*)msg->header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ctx_new_ccache_iterator_t))
+    if (header_len != sizeof(ccmsg_ctx_new_ccache_iterator_t))
         return ccErrBadParam;
 
-    code = cci_context_ccache_iterator(ctx,&ccache_iterator);
+    code = ccs_context_ccache_iterator(ctx, &ccache_iterator);
 
     resp_header = (ccmsg_ctx_new_ccache_iterator_resp_t*)malloc(sizeof(ccmsg_ctx_new_ccache_iterator_resp_t));
     if (resp_header == NULL) 
         return ccErrNoMem;
 
-    resp_header->iterator = ccache_iterator;
+    resp_header->iterator = htonll((cc_handle) ccache_iterator);
 
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ctx_new_ccache_iterator_resp_t), auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ctx_new_ccache_iterator_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32
@@ -571,7 +604,7 @@ ccop_CTX_LOCK( cc_server_context_t* ctx,
                cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 cc_int32
@@ -581,7 +614,7 @@ ccop_CTX_UNLOCK( cc_server_context_t* ctx,
                  cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 cc_int32
@@ -591,11 +624,11 @@ ccop_CTX_CLONE( cc_server_context_t* ctx,
                 cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 cc_int32 
-ccop_CCACHE_OPEN(cc_server_context_t* ctx,
+ccop_CTX_CCACHE_OPEN(cc_server_context_t* ctx,
                   cc_auth_info_t* auth_info,
                   cc_session_info_t* session_info,
                   cc_msg_t *msg, cc_msg_t **resp_msg) 
@@ -604,32 +637,33 @@ ccop_CCACHE_OPEN(cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     ccmsg_ccache_open_resp_t* resp_header;
     ccmsg_ccache_open_t* header = (ccmsg_ccache_open_t*)msg->header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_open_t))
+    if (header_len != sizeof(ccmsg_ccache_open_t))
         return ccErrBadParam;
 
-    code = cci_msg_retrieve_blob(msg, header->name_offset, header->name_len, &name);
-    code = cci_context_find_ccache(ctx, name, &ccache);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->name_offset), ntohl(header->name_len), &name);
+    code = ccs_context_find_ccache(ctx, name, &ccache);
 
     free(name);
 
     if (ccache == NULL)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_open_resp_t*)malloc(sizeof(ccmsg_ccache_open_resp_t));
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->ccache = ccache;
-    cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_open_resp_t), auth_info, session_info, resp_msg);
+    resp_header->ccache = htonll((cc_handle) ccache);
+    ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_open_resp_t), auth_info, session_info, resp_msg);
     return ccNoError;
 }       
 
 cc_int32 
-ccop_CCACHE_OPEN_DEFAULT(cc_server_context_t* ctx,
+ccop_CTX_CCACHE_OPEN_DEFAULT(cc_server_context_t* ctx,
                           cc_auth_info_t* auth_info,
                           cc_session_info_t* session_info,
                           cc_msg_t *msg, cc_msg_t **resp_msg) 
@@ -637,14 +671,15 @@ ccop_CCACHE_OPEN_DEFAULT(cc_server_context_t* ctx,
     ccmsg_ccache_open_default_t* header = (ccmsg_ccache_open_default_t*)msg->header;
     ccmsg_ccache_open_resp_t* resp_header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_open_default_t)) 
+    if (header_len != sizeof(ccmsg_ccache_open_default_t)) 
         return ccErrBadParam;
 
     if (ctx->ccaches->head->data == NULL)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
     
     ccache = (cc_server_ccache_t*) ctx->ccaches->head->data;
 
@@ -652,12 +687,12 @@ ccop_CCACHE_OPEN_DEFAULT(cc_server_context_t* ctx,
     if (resp_header == NULL) 
         return ccErrNoMem;
 
-    resp_header->ccache = ccache;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_open_resp_t), auth_info, session_info, resp_msg);
+    resp_header->ccache = htonll((cc_handle) ccache);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_open_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
-ccop_CCACHE_CREATE(cc_server_context_t* ctx,
+ccop_CTX_CCACHE_CREATE(cc_server_context_t* ctx,
                     cc_auth_info_t* auth_info,
                     cc_session_info_t* session_info,
                     cc_msg_t *msg, cc_msg_t **resp_msg) 
@@ -667,24 +702,25 @@ ccop_CCACHE_CREATE(cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     char* principal;
     char* name;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_create_t)) 
+    if (header_len != sizeof(ccmsg_ccache_create_t)) 
         return ccErrBadParam;
 
-    code = cci_msg_retrieve_blob(msg, header->principal_offset, header->principal_len, &principal);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->principal_offset), ntohl(header->principal_len), &principal);
     if (code != ccNoError) 
         return code;
-    principal[header->principal_len] = '\0'; /*Ensure null termination*/
+    principal[ntohl(header->principal_len)] = '\0'; /*Ensure null termination*/
 
-    code = cci_msg_retrieve_blob(msg, header->name_offset, header->name_len, &name);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->name_offset), ntohl(header->name_len), &name);
     if (code != ccNoError) 
         return code;
-    name[header->name_len] = '\0'; /*Ensure null termination*/
+    name[ntohl(header->name_len)] = '\0'; /*Ensure null termination*/
 
-    code = cci_context_create_ccache(ctx, name, header->version, principal, &ccache);
+    code = ccs_context_create_ccache(ctx, name, ntohl(header->version), principal, &ccache);
     if (code != ccNoError)
         return code;
 
@@ -692,12 +728,12 @@ ccop_CCACHE_CREATE(cc_server_context_t* ctx,
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->ccache = ccache;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
+    resp_header->ccache = htonll((cc_handle) ccache);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
 }
 
 cc_int32 
-ccop_CCACHE_CREATE_DEFAULT( cc_server_context_t* ctx,
+ccop_CTX_CCACHE_CREATE_DEFAULT( cc_server_context_t* ctx,
                             cc_auth_info_t* auth_info,
                             cc_session_info_t* session_info,
                             cc_msg_t *msg, cc_msg_t **resp_msg) 
@@ -707,23 +743,24 @@ ccop_CCACHE_CREATE_DEFAULT( cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     char* principal;
     char* name;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_create_t)) 
+    if (header_len != sizeof(ccmsg_ccache_create_t)) 
         return ccErrBadParam;
 
-    code = cci_msg_retrieve_blob(msg, header->principal_offset, header->principal_len, &principal);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->principal_offset), ntohl(header->principal_len), &principal);
     if (code != ccNoError) 
         return code;
-    principal[header->principal_len] = '\0'; /*Ensure null termination*/
+    principal[ntohl(header->principal_len)] = '\0'; /*Ensure null termination*/
 
-    code = cci_context_get_default_ccache_name(ctx, &name);
+    code = ccs_context_get_default_ccache_name(ctx, &name);
     if (code != ccNoError)
         return code;
 
-    code = cci_context_create_ccache(ctx, name, header->version, principal, &ccache);
+    code = ccs_context_create_ccache(ctx, name, ntohl(header->version), principal, &ccache);
     if (code != ccNoError)
         return code;
 
@@ -731,12 +768,12 @@ ccop_CCACHE_CREATE_DEFAULT( cc_server_context_t* ctx,
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->ccache = ccache;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
+    resp_header->ccache = htonll((cc_handle) ccache);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
 }
 
 cc_int32 
-ccop_CCACHE_CREATE_UNIQUE( cc_server_context_t* ctx,
+ccop_CTX_CCACHE_CREATE_UNIQUE( cc_server_context_t* ctx,
                            cc_auth_info_t* auth_info,
                            cc_session_info_t* session_info,
                            cc_msg_t *msg, cc_msg_t **resp_msg) 
@@ -746,21 +783,23 @@ ccop_CCACHE_CREATE_UNIQUE( cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     char* principal;
     char* name;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_create_t)) 
+    if (header_len != sizeof(ccmsg_ccache_create_t)) 
         return ccErrBadParam;
 
-    code = cci_msg_retrieve_blob(msg, header->principal_offset, header->principal_len, &principal);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->principal_offset), htonl(header->principal_len), &principal);
     if (code != ccNoError) 
         return code;
-    principal[header->principal_len] = '\0'; /*Ensure null termination*/
+    principal[ntohl(header->principal_len)] = '\0'; /*Ensure null termination*/
 
-    // TODO: Generate a unique ccache name 
+    // TODO: Generate a unique ccache name
+    name = "unique";
 
-    code = cci_context_create_ccache(ctx, name, header->version, principal, &ccache);
+    code = ccs_context_create_ccache(ctx, name, ntohl(header->version), principal, &ccache);
     if (code != ccNoError)
         return code;
 
@@ -768,8 +807,8 @@ ccop_CCACHE_CREATE_UNIQUE( cc_server_context_t* ctx,
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->ccache = ccache;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
+    resp_header->ccache = htonll((cc_handle) ccache);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_create_resp_t), auth_info, session_info, resp_msg);
 }
 
 cc_int32 
@@ -790,20 +829,21 @@ ccop_CCACHE_DESTROY( cc_server_context_t* ctx,
 {
     ccmsg_ccache_release_t* header = (ccmsg_ccache_release_t*)msg->header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_release_t)) 
+    if (header_len != sizeof(ccmsg_ccache_release_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    cci_ccache_destroy(ccache);
+    ccs_ccache_destroy(ccache);
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }
 
 cc_int32 
@@ -816,39 +856,40 @@ ccop_CCACHE_SET_DEFAULT(cc_server_context_t* ctx,
     ccmsg_ccache_set_default_t* header = (ccmsg_ccache_set_default_t*)msg->header;
     cc_ccache_iterate_t* ccache_iterator;
     cc_ccache_list_node_t* ccache_node;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_set_default_t))
+    if (header_len != sizeof(ccmsg_ccache_set_default_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     if (ccache == (cc_server_ccache_t*)ctx->ccaches->head->data) /*already default*/
-        return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+        return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 
     old_default = (cc_server_ccache_t*)ctx->ccaches->head->data;
     old_default->last_default = time(NULL);
 
-    code = cci_ccache_list_iterator(ctx->ccaches, &ccache_iterator);
+    code = ccs_ccache_list_iterator(ctx->ccaches, &ccache_iterator);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    while (cci_ccache_iterate_has_next(ccache_iterator)) {
-        code = cci_ccache_iterate_next(ccache_iterator,&ccache_node);
+    while (ccs_ccache_iterate_has_next(ccache_iterator)) {
+        code = ccs_ccache_iterate_next(ccache_iterator,&ccache_node);
         stored_ccache = (cc_server_ccache_t*)ccache_node->data;
 
         if (stored_ccache == ccache) {
             ccache_node->data = NULL; /*don't want list removal code free()ing ccache*/
-            cci_ccache_list_remove_element(ctx->ccaches, ccache_node);
-            cci_ccache_list_prepend(ctx->ccaches, ccache, NULL);
+            ccs_ccache_list_remove_element(ctx->ccaches, ccache_node);
+            ccs_ccache_list_prepend(ctx->ccaches, ccache, NULL);
             break;
         }
     }       
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -860,23 +901,24 @@ ccop_CCACHE_GET_CREDS_VERSION(cc_server_context_t* ctx,
     ccmsg_ccache_get_creds_version_t* header = (ccmsg_ccache_get_creds_version_t*)msg->header;
     ccmsg_ccache_get_creds_version_resp_t* resp_header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_get_creds_version_t))
+    if (header_len != sizeof(ccmsg_ccache_get_creds_version_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_get_creds_version_resp_t*)malloc(sizeof(ccmsg_ccache_get_creds_version_resp_t));	
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->version = ccache->versions;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_creds_version_resp_t), auth_info, session_info, resp_msg);
+    resp_header->version = htonl(ccache->versions);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_creds_version_resp_t), auth_info, session_info, resp_msg);
 }
 
 cc_int32 
@@ -888,16 +930,18 @@ ccop_CCACHE_GET_NAME(cc_server_context_t* ctx,
     ccmsg_ccache_get_name_t* header = (ccmsg_ccache_get_name_t*)msg->header;
     ccmsg_ccache_get_name_resp_t* resp_header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
+    cc_uint32 name_offset;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_get_name_resp_t)) 
+    if (header_len != sizeof(ccmsg_ccache_get_name_resp_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (ccache == NULL)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_get_name_resp_t*)malloc(sizeof(ccmsg_ccache_get_name_resp_t));
     if (resp_header == NULL)
@@ -907,8 +951,11 @@ ccop_CCACHE_GET_NAME(cc_server_context_t* ctx,
     if (code != ccNoError)
         return code;
 
-    code = cci_msg_add_data_blob(*resp_msg, ccache->name, strlen(ccache->name) + 1, &resp_header->name_offset);
-    resp_header->name_len = strlen(ccache->name) + 1;
+    code = cci_msg_add_data_blob(*resp_msg, ccache->name, strlen(ccache->name) + 1, &name_offset);
+    if (code == 0) {
+	resp_header->name_len = htonl(strlen(ccache->name) + 1);
+	resp_header->name_offset = htonl(name_offset);
+    }
     cci_msg_add_header(*resp_msg, resp_header, sizeof(ccmsg_ccache_get_name_resp_t));
 
     return ccNoError;
@@ -924,20 +971,22 @@ ccop_CCACHE_GET_PRINCIPAL(cc_server_context_t* ctx,
     ccmsg_ccache_get_principal_resp_t* resp_header;
     cc_server_ccache_t* ccache;
     char * principal;
+    cc_uint32 header_len = msg->header_len;
+    cc_uint32 principal_offset;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_get_principal_t)) 
+    if (header_len != sizeof(ccmsg_ccache_get_principal_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_ccache_get_principal(ccache, header->version, &principal);
+    code = ccs_ccache_get_principal(ccache, ntohl(header->version), &principal);
     if (code != ccNoError)
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
     code = cci_msg_new(ccmsg_ACK, resp_msg);
     if (code != ccNoError) 
@@ -947,7 +996,11 @@ ccop_CCACHE_GET_PRINCIPAL(cc_server_context_t* ctx,
     if (resp_header == NULL) 
         return ccErrNoMem;
 
-    code = cci_msg_add_data_blob(*resp_msg, principal, strlen(principal) + 1, &resp_header->principal_offset);
+    code = cci_msg_add_data_blob(*resp_msg, principal, strlen(principal) + 1, &principal_offset);
+    if (code == 0) {
+	resp_header->principal_len = htonl(strlen(principal) + 1);
+	resp_header->principal_offset = htonl(principal_offset);
+    }
     cci_msg_add_header(*resp_msg, resp_header, sizeof(ccmsg_ccache_get_principal_resp_t));
 
     return ccNoError;
@@ -962,50 +1015,52 @@ ccop_CCACHE_SET_PRINCIPAL(cc_server_context_t* ctx,
     ccmsg_ccache_set_principal_t* header = (ccmsg_ccache_set_principal_t*)msg->header;
     cc_server_ccache_t* ccache;
     char *principal;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_set_principal_t))
+    if (header_len != sizeof(ccmsg_ccache_set_principal_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_msg_retrieve_blob(msg, header->principal_offset, header->principal_len, &principal);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->principal_offset), ntohl(header->principal_len), &principal);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
-    code = cci_ccache_set_principal(ccache, header->version, principal);
+    code = ccs_ccache_set_principal(ccache, ntohl(header->version), principal);
     if (code != ccNoError)
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
-ccop_CCACHE_CREDS_ITERATOR(cc_server_context_t* ctx,
-                            cc_auth_info_t* auth_info,
-                            cc_session_info_t* session_info,
-                            cc_msg_t *msg, cc_msg_t **resp_msg) 
+ccop_CCACHE_NEW_CREDS_ITERATOR( cc_server_context_t* ctx,
+				cc_auth_info_t* auth_info,
+				cc_session_info_t* session_info,
+				cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     cc_server_ccache_t* ccache;
     cc_credentials_iterate_t* creds_iterator;
     ccmsg_ccache_creds_iterator_t* header = (ccmsg_ccache_creds_iterator_t*)msg->header;
     ccmsg_ccache_creds_iterator_resp_t* resp_header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_creds_iterator_t)) 
+    if (header_len != sizeof(ccmsg_ccache_creds_iterator_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_ccache_new_iterator(ccache, &creds_iterator);
+    code = ccs_ccache_new_iterator(ccache, &creds_iterator);
     if (code != ccNoError)
         return code;
 
@@ -1013,13 +1068,13 @@ ccop_CCACHE_CREDS_ITERATOR(cc_server_context_t* ctx,
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->iterator = creds_iterator;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_creds_iterator_resp_t), auth_info, session_info, resp_msg);
+    resp_header->iterator = htonll((cc_handle) creds_iterator);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_creds_iterator_resp_t), auth_info, session_info, resp_msg);
 }       
 
 
 static cc_int32
-cci_credentials_union_release( cc_credentials_union * creds )
+ccs_credentials_union_release( cc_credentials_union * creds )
 {
     int i;
 
@@ -1069,24 +1124,21 @@ ccop_CCACHE_STORE_CREDS(cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     char                 *flat_creds;
     cc_credentials_union *creds;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_store_creds_t))
+    if (header_len != sizeof(ccmsg_ccache_store_creds_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    // TODO: This code is too simplistic.  cc_credential_unions are not flat
-    // structures and must be flattened.  That means that although we can 
-    // store a flat blob in the message we will need to decode the blob
-    // into the actual object.  
-    code = cci_msg_retrieve_blob(msg, header->creds_offset, header->creds_len, &flat_creds);
+    code = cci_msg_retrieve_blob(msg, ntohl(header->creds_offset), ntohl(header->creds_len), &flat_creds);
     if (code != ccNoError) 
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
     creds = (cc_credentials_union *)malloc(sizeof(cc_credentials_union));
     if ( creds == NULL )
@@ -1094,24 +1146,24 @@ ccop_CCACHE_STORE_CREDS(cc_server_context_t* ctx,
 
     switch ( creds->version ) {        
     case cc_credentials_v4:
-        code = cci_creds_v4_unmarshall(flat_creds, header->creds_len, creds);
+        code = cci_creds_v4_unmarshall(flat_creds, ntohl(header->creds_len), creds);
         break;                                 
     case cc_credentials_v5:
-        code = cci_creds_v5_unmarshall(flat_creds, header->creds_len, creds);
+        code = cci_creds_v5_unmarshall(flat_creds, ntohl(header->creds_len), creds);
         break;
     default:
-        return cci_serv_make_nack(ccErrBadCredentialsVersion, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadCredentialsVersion, auth_info, session_info, resp_msg);
     }
     if (code != ccNoError)
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
-    code = cci_ccache_store_creds(ccache, creds);
-    cci_credentials_union_release(creds);
+    code = ccs_ccache_store_creds(ccache, creds);
+    ccs_credentials_union_release(creds);
     if (code != ccNoError) {
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
     }
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1123,21 +1175,22 @@ ccop_CCACHE_REM_CREDS(cc_server_context_t* ctx,
     ccmsg_ccache_rem_creds_t* header = (ccmsg_ccache_rem_creds_t*)msg->header;
     cc_server_ccache_t* ccache;
     cc_credentials_union *creds;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
-    if (msg->header_len != sizeof(ccmsg_ccache_rem_creds_t))
+    if (header_len != sizeof(ccmsg_ccache_rem_creds_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_ccache_rem_creds(ccache, header->creds);
+    code = ccs_ccache_rem_creds(ccache, (const cc_credentials_union *)(ntohll(header->creds)));
     if (code != ccNoError)
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }               
 
 cc_int32
@@ -1147,7 +1200,7 @@ ccop_CCACHE_LOCK( cc_server_context_t* ctx,
                   cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 cc_int32
@@ -1157,7 +1210,7 @@ ccop_CCACHE_UNLOCK( cc_server_context_t* ctx,
                     cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 cc_int32
@@ -1167,7 +1220,7 @@ ccop_CCACHE_MOVE( cc_server_context_t* ctx,
                   cc_msg_t *msg, cc_msg_t **resp_msg) 
 {
     // TODO
-    return cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
 }
 
 
@@ -1180,23 +1233,24 @@ ccop_CCACHE_GET_LAST_DEFAULT_TIME(cc_server_context_t* ctx,
     ccmsg_ccache_get_last_default_time_t* header = (ccmsg_ccache_get_last_default_time_t*)msg->header;
     ccmsg_ccache_get_last_default_time_resp_t* resp_header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_get_last_default_time_t))
+    if (header_len != sizeof(ccmsg_ccache_get_last_default_time_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_get_last_default_time_resp_t*)malloc(sizeof(ccmsg_ccache_get_last_default_time_resp_t));
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->last_default_time = ccache->last_default;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_last_default_time_resp_t), auth_info, session_info, resp_msg);
+    resp_header->last_default_time = htonll(ccache->last_default);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_last_default_time_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1208,10 +1262,11 @@ ccop_CCACHE_GET_CHANGE_TIME( cc_server_context_t* ctx,
     ccmsg_ccache_get_change_time_resp_t* resp_header;
     ccmsg_ccache_get_change_time_t *header = (ccmsg_ccache_get_change_time_t *)msg->header;
     cc_server_ccache_t* ccache = (cc_server_ccache_t *)header->ccache;
+    cc_uint32 header_len = msg->header_len;
 
     *resp_msg = 0;
 	
-    if (msg->header_len != sizeof(ccmsg_ccache_get_change_time_t)) {
+    if (header_len != sizeof(ccmsg_ccache_get_change_time_t)) {
         return ccErrBadParam;
     }
 
@@ -1220,8 +1275,8 @@ ccop_CCACHE_GET_CHANGE_TIME( cc_server_context_t* ctx,
         return ccErrNoMem;
     }
 
-    resp_header->time = ccache->changed;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_change_time_resp_t), auth_info, session_info, resp_msg);
+    resp_header->time = htonll(ccache->changed);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_change_time_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1233,27 +1288,30 @@ ccop_CCACHE_COMPARE(cc_server_context_t* ctx,
     ccmsg_ccache_compare_t* header = (ccmsg_ccache_compare_t*)msg->header;
     ccmsg_ccache_compare_resp_t* resp_header;
     cc_server_ccache_t* ccache1, *ccache2;
+    cc_uint32 header_len = msg->header_len;
+    cc_uint32 is_equal;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_compare_t))
+    if (header_len != sizeof(ccmsg_ccache_compare_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache1, &ccache1);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache1), &ccache1);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache2, &ccache2);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache2), &ccache2);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_compare_resp_t*)malloc(sizeof(ccmsg_ccache_compare_resp_t));	
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    cci_ccache_compare(ccache1, ccache2, &resp_header->is_equal);
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_compare_resp_t), auth_info, session_info, resp_msg);
+    ccs_ccache_compare(ccache1, ccache2, &is_equal);
+    resp_header->is_equal = htonl(is_equal);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_compare_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1265,30 +1323,31 @@ ccop_CCACHE_GET_KDC_TIME_OFFSET(cc_server_context_t* ctx,
     ccmsg_ccache_get_kdc_time_offset_t* header = (ccmsg_ccache_get_kdc_time_offset_t*)msg->header;
     ccmsg_ccache_get_kdc_time_offset_resp_t* resp_header;
     cc_server_ccache_t* ccache;
-    cc_time_t offset;
+    cc_time64 offset;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_get_kdc_time_offset_t))
+    if (header_len != sizeof(ccmsg_ccache_get_kdc_time_offset_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     // TODO How is the header->creds_version supposed to be used?
 
-    code = cci_ccache_get_kdc_time_offset(ccache, &offset);
+    code = ccs_ccache_get_kdc_time_offset(ccache, &offset);
     if (code != ccNoError)
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
     resp_header = (ccmsg_ccache_get_kdc_time_offset_resp_t*)malloc(sizeof(ccmsg_ccache_get_kdc_time_offset_resp_t));
     if (resp_header == NULL)
         return ccErrNoMem;
 
-    resp_header->offset = offset;
-    return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_kdc_time_offset_resp_t), auth_info, session_info, resp_msg);
+    resp_header->offset = htonll(offset);
+    return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_get_kdc_time_offset_resp_t), auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1299,21 +1358,22 @@ ccop_CCACHE_SET_KDC_TIME_OFFSET(cc_server_context_t* ctx,
 {
     ccmsg_ccache_set_kdc_time_offset_t* header = (ccmsg_ccache_set_kdc_time_offset_t*)msg->header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_set_kdc_time_offset_t))
+    if (header_len != sizeof(ccmsg_ccache_set_kdc_time_offset_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     // TODO How is the header->creds_version supposed to be used?
 
-    cci_ccache_set_kdc_time_offset(ccache, header->offset);
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    ccs_ccache_set_kdc_time_offset(ccache, htonll(header->offset));
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
 cc_int32 
@@ -1324,21 +1384,22 @@ ccop_CCACHE_CLEAR_KDC_TIME_OFFSET(cc_server_context_t* ctx,
 {
     ccmsg_ccache_clear_kdc_time_offset_t* header = (ccmsg_ccache_clear_kdc_time_offset_t*)msg->header;
     cc_server_ccache_t* ccache;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_clear_kdc_time_offset_t))
+    if (header_len != sizeof(ccmsg_ccache_clear_kdc_time_offset_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
     // TODO How is the header->creds_version supposed to be used?
 
-    cci_ccache_clear_kdc_time_offset(ccache);
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    ccs_ccache_clear_kdc_time_offset(ccache);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }               
 
 cc_int32 
@@ -1349,24 +1410,35 @@ ccop_CCACHE_ITERATOR_RELEASE(cc_server_context_t* ctx,
 {
     cc_generic_list_node_t* gen_node;
     ccmsg_ccache_iterator_release_t* header = (ccmsg_ccache_iterator_release_t*)msg->header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_iterator_release_t)) 
+    if (header_len != sizeof(ccmsg_ccache_iterator_release_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_iterator_by_handle(ctx, header->iterator, &gen_node);
+    code = ccs_serv_find_ccache_iterator_by_handle(ctx, ntohll(header->iterator), &gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
     code = cci_generic_list_remove_element(ctx->active_iterators, gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
+cc_int32
+ccop_CCACHE_ITERATOR_CLONE( cc_server_context_t* ctx,
+                cc_auth_info_t* auth_info,
+                cc_session_info_t* session_info,
+                cc_msg_t *msg, cc_msg_t **resp_msg) 
+{
+    // TODO
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+}
+
 cc_int32 
 ccop_CCACHE_ITERATOR_NEXT(cc_server_context_t* ctx,
                            cc_auth_info_t* auth_info,
@@ -1377,32 +1449,33 @@ ccop_CCACHE_ITERATOR_NEXT(cc_server_context_t* ctx,
     ccmsg_ccache_iterator_next_resp_t* resp_header;
     cc_generic_list_node_t* gen_node;
     cc_ccache_iterate_t* ccache_iterator;
-	cc_ccache_list_node_t *ccache_node;
+    cc_ccache_list_node_t *ccache_node;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_ccache_iterator_next_t)) 
+    if (header_len != sizeof(ccmsg_ccache_iterator_next_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_iterator_by_handle(ctx, header->iterator, &gen_node);
+    code = ccs_serv_find_ccache_iterator_by_handle(ctx, ntohll(header->iterator), &gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
     ccache_iterator = (cc_ccache_iterate_t*)gen_node->data;
-    if (cci_ccache_iterate_has_next(ccache_iterator)) {
+    if (ccs_ccache_iterate_has_next(ccache_iterator)) {
         resp_header = (ccmsg_ccache_iterator_next_resp_t*)malloc(sizeof(ccmsg_ccache_iterator_next_resp_t));
         if (resp_header == NULL)
             return ccErrNoMem;
 
-        code = cci_ccache_iterate_next(ccache_iterator, &ccache_node);
+        code = ccs_ccache_iterate_next(ccache_iterator, &ccache_node);
         if (code != ccNoError) 
-            return cci_serv_make_nack(code, auth_info, session_info, resp_msg);
+            return ccs_serv_make_nack(code, auth_info, session_info, resp_msg);
 
-		resp_header->ccache = ccache_node;
-        return cci_serv_make_ack(resp_header, sizeof(ccmsg_ccache_iterator_next_resp_t), auth_info, session_info, resp_msg);
+	resp_header->ccache = htonll((cc_handle) ccache_node);
+        return ccs_serv_make_ack(resp_header, sizeof(ccmsg_ccache_iterator_next_resp_t), auth_info, session_info, resp_msg);
     } else {
-        return cci_serv_make_nack(ccIteratorEnd, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccIteratorEnd, auth_info, session_info, resp_msg);
     }
 }       
 
@@ -1415,28 +1488,40 @@ ccop_CREDS_ITERATOR_RELEASE(cc_server_context_t* ctx,
     cc_generic_list_node_t* gen_node;
     cc_server_ccache_t* ccache;
     ccmsg_creds_iterator_release_t* header = (ccmsg_creds_iterator_release_t*)msg->header;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_creds_iterator_release_t)) 
+    if (header_len != sizeof(ccmsg_creds_iterator_release_t)) 
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_serv_find_creds_iterator_by_handle(ccache, header->iterator, &gen_node);
+    code = ccs_serv_find_creds_iterator_by_handle(ccache, ntohll(header->iterator), &gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
     code = cci_generic_list_remove_element(ccache->active_iterators, gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
-    return cci_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
+    return ccs_serv_make_ack(NULL, 0, auth_info, session_info, resp_msg);
 }       
 
+cc_int32
+ccop_CREDS_ITERATOR_CLONE( cc_server_context_t* ctx,
+                cc_auth_info_t* auth_info,
+                cc_session_info_t* session_info,
+                cc_msg_t *msg, cc_msg_t **resp_msg) 
+{
+    // TODO
+    return ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+}
+
+
 cc_int32 
 ccop_CREDS_ITERATOR_NEXT(cc_server_context_t* ctx,
                           cc_auth_info_t* auth_info,
@@ -1451,23 +1536,24 @@ ccop_CREDS_ITERATOR_NEXT(cc_server_context_t* ctx,
     cc_server_ccache_t* ccache;
     cc_server_credentials_t* stored_creds;
     cc_credentials_union *creds_union;
+    cc_uint32 header_len = msg->header_len;
     cc_int32 code;
 
     *resp_msg = 0;
 
-    if (msg->header_len != sizeof(ccmsg_creds_iterator_next_t))
+    if (header_len != sizeof(ccmsg_creds_iterator_next_t))
         return ccErrBadParam;
 
-    code = cci_serv_find_ccache_by_handle(ctx, header->ccache, &ccache);
+    code = ccs_serv_find_ccache_by_handle(ctx, ntohll(header->ccache), &ccache);
     if (code != ccNoError)
-        return cci_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrCCacheNotFound, auth_info, session_info, resp_msg);
 
-    code = cci_serv_find_creds_iterator_by_handle(ccache, header->iterator, &gen_node);
+    code = ccs_serv_find_creds_iterator_by_handle(ccache, ntohll(header->iterator), &gen_node);
     if (code != ccNoError) 
-        return cci_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
+        return ccs_serv_make_nack(ccErrBadParam, auth_info, session_info, resp_msg);
 
     creds_iterator = (cc_credentials_iterate_t*)gen_node->data;
-    if (cci_credentials_iterate_has_next(creds_iterator)) {
+    if (ccs_credentials_iterate_has_next(creds_iterator)) {
         code = cci_msg_new(ccmsg_ACK, resp_msg);
         if (code != ccNoError)
             return code;
@@ -1476,14 +1562,14 @@ ccop_CREDS_ITERATOR_NEXT(cc_server_context_t* ctx,
         if (resp_header == NULL)
             return ccErrNoMem;
 
-        code = cci_credentials_iterate_next(creds_iterator, &creds_node);
+        code = ccs_credentials_iterate_next(creds_iterator, &creds_node);
         stored_creds = (cc_server_credentials_t*)creds_node->data;
         creds_union = &stored_creds->creds;
 
         code = cci_msg_add_data_blob(*resp_msg, creds_union, sizeof(cc_credentials_union), &resp_header->creds_offset);
         code = cci_msg_add_header(*resp_msg, resp_header, sizeof(ccmsg_creds_iterator_next_resp_t));
     } else {
-        cci_serv_make_nack(ccIteratorEnd, auth_info, session_info, resp_msg);
+        ccs_serv_make_nack(ccIteratorEnd, auth_info, session_info, resp_msg);
     }
     return ccNoError;
 }       
@@ -1495,6 +1581,6 @@ ccop_CREDS_RELEASE( cc_server_context_t* ctx,
                     cc_msg_t *msg, cc_msg_t **resp_msg) 
 {       
         
-    cci_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
+    ccs_serv_make_nack(ccErrNotImplemented, auth_info, session_info, resp_msg);
     return ccNoError;
 }