From 4e824737afa8bb05db07d92a04855149c2fba5d8 Mon Sep 17 00:00:00 2001 From: Jeffrey Altman Date: Fri, 19 May 2006 09:18:37 +0000 Subject: Updates of portable CCAPI sources. All code compiles git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18022 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/ccapi/client/NTMakefile | 4 +- src/lib/ccapi/client/cacheapi.c | 42 +- src/lib/ccapi/client/cacheapi.def | 29 ++ src/lib/ccapi/client/ccache.c | 482 +++++++++++---------- src/lib/ccapi/client/ccache.h | 10 +- src/lib/ccapi/client/ccache_iterator.c | 93 +++- src/lib/ccapi/client/ccache_iterator.h | 6 +- src/lib/ccapi/client/ccapiv2.c | 286 +++++++++++++ src/lib/ccapi/client/context.c | 337 ++++++++------- src/lib/ccapi/client/context.h | 2 +- src/lib/ccapi/client/credentials.c | 14 +- src/lib/ccapi/client/credentials.h | 6 +- src/lib/ccapi/client/credentials_iterator.c | 104 ++++- src/lib/ccapi/client/credentials_iterator.h | 6 +- src/lib/ccapi/client/marshall.c | 445 ++++++++++++++++++++ src/lib/ccapi/client/msg.c | 628 ++++++++++++++++++++++++++++ 16 files changed, 2057 insertions(+), 437 deletions(-) create mode 100644 src/lib/ccapi/client/cacheapi.def create mode 100644 src/lib/ccapi/client/ccapiv2.c create mode 100644 src/lib/ccapi/client/marshall.c create mode 100644 src/lib/ccapi/client/msg.c (limited to 'src/lib/ccapi/client') diff --git a/src/lib/ccapi/client/NTMakefile b/src/lib/ccapi/client/NTMakefile index 09ef9df38b..57ff87416e 100644 --- a/src/lib/ccapi/client/NTMakefile +++ b/src/lib/ccapi/client/NTMakefile @@ -12,11 +12,11 @@ $(CCAPI_LIB): $(CCAPI_OBJS) CCAPI_DLLFILE = krbcc32.dll - - $(CCAPI_DLLFILE): $(CCAPI_LIB) $(DLLGUILINK) -def:windows\krbcc32.def $(DLLPREP) +all: $(CCAPI_DLLFILE) + clean: del *.obj *.lib diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c index 2c874bec0f..704925dfd7 100644 --- a/src/lib/ccapi/client/cacheapi.c +++ b/src/lib/ccapi/client/cacheapi.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,10 +47,17 @@ #include "ccache.h" #include "ccache_iterator.h" #include "context.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" -cc_int32 +/*! \fn cc_initialize + * \brief A function that initializes a ccapi context for the caller. + * \param[out] outContext a cc_context_t pointer to which is assigned the newly created context upon success. + * \param[in] inVersion a cc_int32 that specifies the + */ + +CCACHE_API cc_int32 cc_initialize ( cc_context_t* outContext, cc_int32 inVersion, cc_int32* outSupportedVersion, @@ -60,16 +67,18 @@ cc_initialize ( cc_context_t* outContext, cc_msg_t *request; ccmsg_init_t *request_header; cc_msg_t *response; + cc_uint32 type; ccmsg_init_resp_t *response_header; cc_int32 code; if ((inVersion != ccapi_version_2) && (inVersion != ccapi_version_3) && (inVersion != ccapi_version_4) && - (inVersion != ccapi_version_5)) { + (inVersion != ccapi_version_5) && + (inVersion != ccapi_version_6)) { if (outSupportedVersion != NULL) { - *outSupportedVersion = ccapi_version_5; + *outSupportedVersion = ccapi_version_6; } return ccErrBadAPIVersion; } @@ -78,7 +87,17 @@ cc_initialize ( cc_context_t* outContext, if (request_header == NULL) return ccErrNoMem; - request_header->in_version = inVersion; + /* If the version number is 2, the caller will be passing + * the structure into the v2 compatibility functions which + * in turn will call the v6 functions. Set the version to + * ccapi_version_max since that is what the compatibility + * functions will be expecting. + */ + if (inVersion == ccapi_version_2) + inVersion = ccapi_version_max; + + /* Construct the request */ + request_header->in_version = htonl(inVersion); code = cci_msg_new(ccmsg_INIT, &request); if (code != ccNoError) { @@ -90,17 +109,18 @@ cc_initialize ( cc_context_t* outContext, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_init_resp_t *)response->header; - *outSupportedVersion = response_header->out_version; - code = cc_context_int_new(outContext, response_header->out_ctx, response_header->out_version); + *outSupportedVersion = ntohl(response_header->out_version); + code = cc_int_context_new(outContext, ntohl(response_header->out_ctx), ntohl(response_header->out_version)); if (!vendor[0]) { char * string; - code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string); + code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string); strncpy(vendor, string, sizeof(vendor)-1); vendor[sizeof(vendor)-1] = '\0'; free(string); diff --git a/src/lib/ccapi/client/cacheapi.def b/src/lib/ccapi/client/cacheapi.def new file mode 100644 index 0000000000..c54cc11068 --- /dev/null +++ b/src/lib/ccapi/client/cacheapi.def @@ -0,0 +1,29 @@ +EXPORTS + ; ccapi v3 only exports one function + cc_initialize @14 + + ; ccapi v2 compatibility functions + cc_close @2 + cc_create @3 + cc_destroy @4 + cc_free_NC_info @5 + cc_free_creds @6 + cc_free_name @7 + cc_free_principal @8 + cc_get_NC_info @9 + cc_get_change_time @10 + cc_get_cred_version @11 + cc_get_name @12 + cc_get_principal @13 + cc_lock_request @15 + cc_open @16 + cc_remove_cred @17 + cc_seq_fetch_NCs_begin @18 + cc_seq_fetch_NCs_end @19 + cc_seq_fetch_NCs_next @20 + cc_seq_fetch_creds_begin @21 + cc_seq_fetch_creds_end @22 + cc_seq_fetch_creds_next @23 + cc_set_principal @24 + cc_shutdown @25 + cc_store @26 diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c index 5de3880e4f..42064d54de 100644 --- a/src/lib/ccapi/client/ccache.c +++ b/src/lib/ccapi/client/ccache.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -49,9 +49,16 @@ #include #include "credentials.h" #include "ccache.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" +/* + * cc_int_ccache_new + * + * Input parameters in host order. + */ + cc_int32 cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache ) { @@ -97,11 +104,12 @@ cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache ) cc_int32 cc_int_ccache_release( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_release_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_release_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -114,8 +122,8 @@ cc_int_ccache_release( cc_ccache_t ccache ) request_header = (ccmsg_ccache_release_t*)malloc(sizeof(ccmsg_ccache_release_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_RELEASE, &request); if (code != ccNoError) { @@ -127,10 +135,11 @@ cc_int_ccache_release( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -146,11 +155,12 @@ cc_int_ccache_release( cc_ccache_t ccache ) cc_int32 cc_int_ccache_destroy( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_destroy_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_destroy_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -163,8 +173,8 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) request_header = (ccmsg_ccache_destroy_t*)malloc(sizeof(ccmsg_ccache_destroy_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_DESTROY, &request); if (code != ccNoError) { @@ -176,10 +186,11 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -194,11 +205,12 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) cc_int32 cc_int_ccache_set_default( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_set_default_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_set_default_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -211,8 +223,8 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) request_header = (ccmsg_ccache_set_default_t*)malloc(sizeof(ccmsg_ccache_set_default_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_SET_DEFAULT, &request); if (code != ccNoError) { @@ -224,10 +236,11 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -241,11 +254,12 @@ cc_int32 cc_int_ccache_get_credentials_version( cc_ccache_t ccache, cc_uint32* credentials_version) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_creds_version_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -258,8 +272,8 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_creds_version_t*)malloc(sizeof(ccmsg_ccache_get_creds_version_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CREDS_VERSION, &request); if (code != ccNoError) { @@ -271,12 +285,13 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_creds_version_resp_t * response_header = (ccmsg_ccache_get_creds_version_resp_t*)response->header; - *credentials_version = response_header->version; + *credentials_version = ntohl(response_header->version); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -287,14 +302,14 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, } cc_int32 -cc_int_ccache_get_name( cc_ccache_t ccache, - cc_string_t* name ) +cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_name_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -307,8 +322,8 @@ cc_int_ccache_get_name( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_name_t*)malloc(sizeof(ccmsg_ccache_get_name_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_NAME, &request); if (code != ccNoError) { @@ -320,10 +335,11 @@ cc_int_ccache_get_name( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * string; ccmsg_ccache_get_name_resp_t * response_header = (ccmsg_ccache_get_name_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->name_offset, @@ -345,11 +361,12 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, cc_uint32 credentials_version, cc_string_t* principal ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_principal_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -362,9 +379,9 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_principal_t*)malloc(sizeof(ccmsg_ccache_get_principal_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); if (code != ccNoError) { @@ -376,10 +393,11 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * string; ccmsg_ccache_get_principal_resp_t * response_header = (ccmsg_ccache_get_principal_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->principal_offset, @@ -401,12 +419,13 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, cc_uint32 credentials_version, const char* principal ) { - cc_uint32 blob_pos; - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_set_principal_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -419,9 +438,9 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, request_header = (ccmsg_ccache_set_principal_t*)malloc(sizeof(ccmsg_ccache_set_principal_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); if (code != ccNoError) { @@ -436,17 +455,18 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, return code; } - request_header->principal_offset = blob_pos; - request_header->principal_len = strlen(principal) + 1; + request_header->principal_offset = htonl(blob_pos); + request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_principal_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -460,11 +480,12 @@ cc_int32 cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, cc_credentials_iterator_t* iterator ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_creds_iterator_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -477,10 +498,10 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, request_header = (ccmsg_ccache_creds_iterator_t*)malloc(sizeof(ccmsg_ccache_creds_iterator_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); - code = cci_msg_new(ccmsg_CCACHE_CREDS_ITERATOR, &request); + code = cci_msg_new(ccmsg_CCACHE_NEW_CREDS_ITERATOR, &request); if (code != ccNoError) { free(request_header); return code; @@ -490,12 +511,14 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_creds_iterator_resp_t * response_header = (ccmsg_ccache_creds_iterator_resp_t*)response->header; - code = cc_int_credentials_iterator_new(iterator, response_header->iterator); + code = cc_int_credentials_iterator_new(iterator, int_ccache->ctx, int_ccache->handle, + ntohll(response_header->iterator)); } else { code = ccErrBadInternalMessage; } @@ -508,14 +531,15 @@ cc_int32 cc_int_ccache_store_credentials( cc_ccache_t ccache, const cc_credentials_union* credentials ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_store_creds_t *request_header; - cc_msg_t *response; - char *flat_cred = 0; - cc_uint32 flat_cred_len = 0; - cc_uint32 blob_pos; - cc_int32 code; + cc_msg_t *response; + char *flat_cred = 0; + cc_uint32 flat_cred_len = 0; + cc_uint32 blob_pos; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || credentials == NULL ) return ccErrBadParam; @@ -528,8 +552,8 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, request_header = (ccmsg_ccache_store_creds_t*)malloc(sizeof(ccmsg_ccache_store_creds_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_STORE_CREDS, &request); if (code != ccNoError) { @@ -562,18 +586,19 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, return code; } - request_header->creds_version = credentials->version; - request_header->creds_offset = blob_pos; - request_header->creds_len = flat_cred_len; + request_header->creds_version = htonl(credentials->version); + request_header->creds_offset = htonl(blob_pos); + request_header->creds_len = htonl(flat_cred_len); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_store_creds_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -588,12 +613,13 @@ cc_int32 cc_int_ccache_remove_credentials( cc_ccache_t ccache, cc_credentials_t credentials ) { - cc_int_ccache_t int_ccache; - cc_int_credentials_t int_creds; - cc_msg_t *request; - ccmsg_ccache_rem_creds_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_int_credentials_t int_creds; + cc_msg_t *request; + ccmsg_ccache_rem_creds_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || credentials == NULL ) return ccErrBadParam; @@ -611,9 +637,9 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds = int_creds->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds = htonll(int_creds->handle); code = cci_msg_new(ccmsg_CCACHE_REM_CREDS, &request); if (code != ccNoError) { @@ -625,10 +651,11 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -643,12 +670,13 @@ cc_int32 cc_int_ccache_move( cc_ccache_t source, cc_ccache_t destination ) { - cc_int_ccache_t int_ccache_source; - cc_int_ccache_t int_ccache_dest; - cc_msg_t *request; + cc_int_ccache_t int_ccache_source; + cc_int_ccache_t int_ccache_dest; + cc_msg_t *request; ccmsg_ccache_move_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( source == NULL || destination == NULL ) return ccErrBadParam; @@ -673,18 +701,19 @@ cc_int_ccache_move( cc_ccache_t source, return code; } - request_header->ctx = int_ccache_source->ctx; - request_header->ccache_source = int_ccache_source->handle; - request_header->ccache_dest = int_ccache_dest->handle; + request_header->ctx = htonll(int_ccache_source->ctx); + request_header->ccache_source = htonll(int_ccache_source->handle); + request_header->ccache_dest = htonll(int_ccache_dest->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_move_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -698,14 +727,16 @@ cc_int_ccache_lock( cc_ccache_t ccache, cc_uint32 lock_type, cc_uint32 block ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_lock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || - (lock_type != cc_lock_read && lock_type != cc_lock_write) || + (lock_type != cc_lock_read && lock_type != cc_lock_write && + lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) || (block != cc_lock_block && block != cc_lock_noblock) ) return ccErrBadParam; @@ -724,17 +755,18 @@ cc_int_ccache_lock( cc_ccache_t ccache, return code; } - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->lock_type; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->lock_type = htonl(lock_type); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_lock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); // TODO: if (block == cc_lock_block) ..... } else if (response->type == ccmsg_ACK) { @@ -750,11 +782,12 @@ cc_int_ccache_lock( cc_ccache_t ccache, cc_int32 cc_int_ccache_unlock( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_unlock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_unlock_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -774,17 +807,18 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) return code; } - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_unlock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = htonl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = htonl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -797,13 +831,15 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) cc_int32 cc_int_ccache_get_last_default_time( cc_ccache_t ccache, - cc_time_t* time_offset ) + cc_time* time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_last_default_time_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_time64 t64; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -816,8 +852,8 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_last_default_time_t*)malloc(sizeof(ccmsg_ccache_get_last_default_time_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_LAST_DEFAULT_TIME, &request); if (code != ccNoError) { @@ -829,13 +865,16 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_last_default_time_resp_t * response_header = (ccmsg_ccache_get_last_default_time_resp_t*)response->header; - *time_offset = response_header->last_default_time; - code = ccNoError; + t64 = ntohll(response_header->last_default_time); + /* TODO: validate that we do not overflow the max value of time_offset */ + *time_offset = t64; + code = ccNoError; } else { code = ccErrBadInternalMessage; } @@ -845,14 +884,15 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, } cc_int32 -cc_int_ccache_get_change_time( cc_ccache_t ccache, - cc_time_t* time ) +cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_change_time_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_time64 t64; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -865,8 +905,8 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_change_time_t*)malloc(sizeof(ccmsg_ccache_get_change_time_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CHANGE_TIME, &request); if (code != ccNoError) { @@ -878,12 +918,15 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_change_time_resp_t * response_header = (ccmsg_ccache_get_change_time_resp_t*)response->header; - *time = response_header->time; + t64 = htonll(response_header->time); + /* TODO: validate that we do not overflow 'time' */ + *time = t64; code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -898,12 +941,13 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_ccache_t compare_to, cc_uint32* equal ) { - cc_int_ccache_t int_ccache; - cc_int_ccache_t int_compare_to; - cc_msg_t *request; - ccmsg_ccache_compare_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_int_ccache_t int_compare_to; + cc_msg_t *request; + ccmsg_ccache_compare_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -918,9 +962,9 @@ cc_int_ccache_compare( cc_ccache_t ccache, request_header = (ccmsg_ccache_compare_t*)malloc(sizeof(ccmsg_ccache_compare_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache1 = int_ccache->handle; - request_header->ccache2 = int_compare_to->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache1 = htonll(int_ccache->handle); + request_header->ccache2 = htonll(int_compare_to->handle); code = cci_msg_new(ccmsg_CCACHE_COMPARE, &request); if (code != ccNoError) { @@ -932,12 +976,13 @@ cc_int_ccache_compare( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_compare_resp_t * response_header = (ccmsg_ccache_compare_resp_t*)response->header; - *equal = response_header->is_equal; + *equal = ntohl(response_header->is_equal); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -950,13 +995,14 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_int32 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t* time_offset ) + cc_time* time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -969,9 +1015,9 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_get_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -983,12 +1029,13 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); } else if (response->type == ccmsg_ACK) { ccmsg_ccache_get_kdc_time_offset_resp_t * response_header = (ccmsg_ccache_get_kdc_time_offset_resp_t*)response->header; - *time_offset = response_header->offset; + *time_offset = ntohll(response_header->offset); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1001,13 +1048,15 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t time_offset ) + cc_time time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_set_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_int64 t64; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -1020,9 +1069,11 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_set_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_set_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); + t64 = time_offset; + request_header->offset = htonll(t64); code = cci_msg_new(ccmsg_CCACHE_SET_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -1034,10 +1085,11 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1051,11 +1103,12 @@ cc_int32 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_clear_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -1068,9 +1121,9 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_clear_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_clear_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_CLEAR_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -1082,10 +1135,11 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1094,5 +1148,3 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, cci_msg_destroy(response); return code; } - - diff --git a/src/lib/ccapi/client/ccache.h b/src/lib/ccapi/client/ccache.h index e3b3993ee0..0a92ebf63d 100644 --- a/src/lib/ccapi/client/ccache.h +++ b/src/lib/ccapi/client/ccache.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -114,11 +114,11 @@ cc_int_ccache_unlock( cc_ccache_t ccache ); cc_int32 cc_int_ccache_get_last_default_time( cc_ccache_t ccache, - cc_time_t* time ); + cc_time* time ); cc_int32 cc_int_ccache_get_change_time( cc_ccache_t ccache, - cc_time_t* time ); + cc_time* time ); cc_int32 cc_int_ccache_compare( cc_ccache_t ccache, @@ -128,12 +128,12 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_int32 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t* time_offset ); + cc_time* time_offset ); cc_int32 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t time_offset ); + cc_time time_offset ); cc_int32 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, diff --git a/src/lib/ccapi/client/ccache_iterator.c b/src/lib/ccapi/client/ccache_iterator.c index 03266b1bbe..3f3e1675e2 100644 --- a/src/lib/ccapi/client/ccache_iterator.c +++ b/src/lib/ccapi/client/ccache_iterator.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,6 +47,7 @@ #include #include #include "ccache_iterator.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" @@ -84,11 +85,12 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter, cc_int32 cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) { - cc_int_ccache_iterator_t int_iter; - cc_msg_t *request; + cc_int_ccache_iterator_t int_iter; + cc_msg_t *request; ccmsg_ccache_iterator_release_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( iter == NULL ) @@ -102,8 +104,8 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) request_header = (ccmsg_ccache_iterator_release_t*)malloc(sizeof(ccmsg_ccache_iterator_release_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_iter->ctx; - request_header->iterator = int_iter->handle; + request_header->ctx = htonll(int_iter->ctx); + request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CCACHE_ITERATOR_RELEASE, &request); if (code != ccNoError) { free(request_header); @@ -114,10 +116,11 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -134,11 +137,12 @@ cc_int32 cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, cc_ccache_t * ccache ) { - cc_int_ccache_iterator_t int_iter; - cc_msg_t *request; + cc_int_ccache_iterator_t int_iter; + cc_msg_t *request; ccmsg_ccache_iterator_next_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -151,8 +155,8 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, request_header = (ccmsg_ccache_iterator_next_t*)malloc(sizeof(ccmsg_ccache_iterator_next_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_iter->ctx; - request_header->iterator = int_iter->handle; + request_header->ctx = htonll(int_iter->ctx); + request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CCACHE_ITERATOR_NEXT, &request); if (code != ccNoError) { @@ -164,12 +168,63 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + } else if (type == ccmsg_ACK) { ccmsg_ccache_iterator_next_resp_t * response_header = (ccmsg_ccache_iterator_next_resp_t*)response->header; - code = cc_ccache_new(ccache, int_iter->ctx, response_header->ccache); + code = cc_int_ccache_new(ccache, int_iter->ctx, ntohll(response_header->ccache)); + } else { + code = ccErrBadInternalMessage; + } + cci_msg_destroy(request); + cci_msg_destroy(response); + return code; +} + +cc_int32 +cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter, + cc_ccache_iterator_t * new_iter ) +{ + cc_int_ccache_iterator_t int_iter; + cc_msg_t *request; + ccmsg_ccache_iterator_clone_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; + + if ( iter == NULL || new_iter == NULL ) + return ccErrBadParam; + + int_iter = (cc_int_ccache_iterator_t)iter; + + if ( int_iter->magic != CC_CCACHE_ITER_MAGIC ) + return ccErrInvalidCCacheIterator; + + request_header = (ccmsg_ccache_iterator_clone_t*)malloc(sizeof(ccmsg_ccache_iterator_clone_t)); + if (request_header == NULL) + return ccErrNoMem; + request_header->ctx = htonll(int_iter->ctx); + request_header->iterator = htonll(int_iter->handle); + + code = cci_msg_new(ccmsg_CCACHE_ITERATOR_CLONE, &request); + if (code != ccNoError) { + free(request_header); + return code; + } + + code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_clone_t)); + + code = cci_perform_rpc(request, &response); + + type = ntohl(response->type); + if (type == ccmsg_NACK) { + ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { + ccmsg_ccache_iterator_clone_resp_t * response_header = (ccmsg_ccache_iterator_clone_resp_t*)response->header; + code = cc_int_ccache_iterator_new(new_iter, int_iter->ctx, ntohll(response_header->iterator)); } else { code = ccErrBadInternalMessage; } diff --git a/src/lib/ccapi/client/ccache_iterator.h b/src/lib/ccapi/client/ccache_iterator.h index c55d72ee67..5a390b82ed 100644 --- a/src/lib/ccapi/client/ccache_iterator.h +++ b/src/lib/ccapi/client/ccache_iterator.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -73,6 +73,10 @@ cc_int32 cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, cc_ccache_t * ccache ); +cc_int32 +cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter, + cc_ccache_iterator_t * iter_new ); + cc_int32 cc_int_ccache_iterator_set_repeat_count( cc_int_ccache_iterator_t iter, cc_uint32 count ); diff --git a/src/lib/ccapi/client/ccapiv2.c b/src/lib/ccapi/client/ccapiv2.c new file mode 100644 index 0000000000..ffbb589a24 --- /dev/null +++ b/src/lib/ccapi/client/ccapiv2.c @@ -0,0 +1,286 @@ +/* $Copyright: + * + * Copyright 1998-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ +/* + * This is backwards compatibility for CCache API v2 clients to be able to run + * against the CCache API v3 library + */ + +#include "CredentialsCache2.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +CCACHE_API cc_int32 cc_shutdown ( + apiCB** ioContext) +{ + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_NC_info ( + apiCB* inContext, + infoNC*** outInfo) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_change_time ( + apiCB* inContext, + cc_time_t* outTime) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_open ( + apiCB* inContext, + const char* inName, + cc_int32 inVersion, + cc_uint32 inFlags, + ccache_p** outCCache) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_create ( + apiCB* inContext, + const char* inName, + const char* inPrincipal, + cc_int32 inVersion, + cc_uint32 inFlags, + ccache_p** outCCache) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_close ( + apiCB* inContext, + ccache_p** ioCCache) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_destroy ( + apiCB* inContext, + ccache_p** ioCCache) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_begin ( + apiCB* inContext, + ccache_cit** outIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_next ( + apiCB* inContext, + ccache_p** outCCache, + ccache_cit* inIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_end ( + apiCB* inContext, + ccache_cit** ioIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_name ( + apiCB* inContext, + ccache_p* inCCache, + char** outName) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_cred_version ( + apiCB* inContext, + ccache_p* inCCache, + cc_int32* outVersion) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_set_principal ( + apiCB* inContext, + ccache_p* inCCache, + cc_int32 inVersion, + char* inPrincipal) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_principal ( + apiCB* inContext, + ccache_p* inCCache, + char** outPrincipal) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_store ( + apiCB* inContext, + ccache_p* inCCache, + cred_union inCredentials) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_remove_cred ( + apiCB* inContext, + ccache_p* inCCache, + cred_union inCredentials) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_begin ( + apiCB* inContext, + const ccache_p* inCCache, + ccache_cit** outIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_next ( + apiCB* inContext, + cred_union** outCreds, + ccache_cit* inIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_end ( + apiCB* inContext, + ccache_cit** ioIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_principal ( + apiCB* inContext, + char** ioPrincipal) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_name ( + apiCB* inContext, + char** ioName) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_creds ( + apiCB* inContext, + cred_union** creds) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_NC_info ( + apiCB* inContext, + infoNC*** ioInfo) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c index 86c41b8e70..efac3020c8 100644 --- a/src/lib/ccapi/client/context.c +++ b/src/lib/ccapi/client/context.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,9 +47,15 @@ #include #include #include "context.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" +/* cc_int_context_new + * + * input parameters (handle, version) are in host order + */ + cc_int32 cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version ) { @@ -87,11 +93,13 @@ cc_int_context_new( cc_context_t * pcontext, cc_handle handle, cc_uint32 version cc_int32 cc_int_context_release( cc_context_t context ) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ctx_release_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_time64 t64; + cc_int32 code; if ( context == NULL ) return ccErrBadParam; @@ -104,7 +112,7 @@ cc_int_context_release( cc_context_t context ) request_header = (ccmsg_ctx_release_t*)malloc(sizeof(ccmsg_ctx_release_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_context->handle; + request_header->ctx = htonl(int_context->handle); code = cci_msg_new(ccmsg_CTX_RELEASE, &request); if (code != ccNoError) { @@ -116,10 +124,11 @@ cc_int_context_release( cc_context_t context ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -133,14 +142,16 @@ cc_int_context_release( cc_context_t context ) cc_int32 cc_int_context_get_change_time( cc_context_t context, - cc_time_t* time) + cc_time* time) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ctx_get_change_time_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ctx_get_change_time_resp_t *response_header; - cc_int32 code; + cc_time64 t64; + cc_uint32 type; + cc_int32 code; if ( context == NULL || time == NULL ) return ccErrBadParam; @@ -153,7 +164,7 @@ cc_int_context_get_change_time( cc_context_t context, request_header = (ccmsg_ctx_get_change_time_t*)malloc(sizeof(ccmsg_ctx_get_change_time_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_context->handle; + request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_GET_CHANGE_TIME, &request); if (code != ccNoError) { @@ -165,12 +176,15 @@ cc_int_context_get_change_time( cc_context_t context, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); } else if (response->type == ccmsg_ACK) { response_header = (ccmsg_ctx_get_change_time_resp_t*)response->header; - *time = response_header->time; + t64 = ntohll(response_header->time); + /* TODO: validate that value is not greater than can fit in cc_time */ + *time = (cc_time)t64; code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -184,12 +198,13 @@ cc_int32 cc_int_context_get_default_ccache_name( cc_context_t context, cc_string_t* name ) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ctx_get_default_ccache_name_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ctx_get_default_ccache_name_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || name == NULL ) return ccErrBadParam; @@ -202,7 +217,7 @@ cc_int_context_get_default_ccache_name( cc_context_t context, request_header = (ccmsg_ctx_get_default_ccache_name_t*)malloc(sizeof(ccmsg_ctx_get_default_ccache_name_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_context->handle; + request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_GET_DEFAULT_CCACHE_NAME, &request); if (code != ccNoError) { @@ -214,10 +229,11 @@ cc_int_context_get_default_ccache_name( cc_context_t context, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * string; response_header = (ccmsg_ctx_get_default_ccache_name_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->name_offset, @@ -244,7 +260,8 @@ cc_int_context_compare( cc_context_t context, ccmsg_ctx_compare_t *request_header; cc_msg_t *response; ccmsg_ctx_compare_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || compare_to == NULL || equal == NULL ) @@ -260,8 +277,8 @@ cc_int_context_compare( cc_context_t context, request_header = (ccmsg_ctx_compare_t*)malloc(sizeof(ccmsg_ctx_compare_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx1 = int_context->handle; - request_header->ctx2 = int_compare_to->handle; + request_header->ctx1 = htonl(int_context->handle); + request_header->ctx2 = htonl(int_compare_to->handle); code = cci_msg_new(ccmsg_CTX_COMPARE, &request); if (code != ccNoError) { @@ -273,12 +290,13 @@ cc_int_context_compare( cc_context_t context, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ctx_compare_resp_t*)response->header; - *equal = response_header->is_equal; + *equal = ntohl(response_header->is_equal); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -293,12 +311,13 @@ cc_int32 cc_int_context_new_ccache_iterator( cc_context_t context, cc_ccache_iterator_t* iterator ) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ctx_new_ccache_iterator_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ctx_new_ccache_iterator_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || iterator == NULL ) return ccErrBadParam; @@ -311,7 +330,7 @@ cc_int_context_new_ccache_iterator( cc_context_t context, request_header = (ccmsg_ctx_new_ccache_iterator_t*)malloc(sizeof(ccmsg_ctx_new_ccache_iterator_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_context->handle; + request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_NEW_CCACHE_ITERATOR, &request); if (code != ccNoError) { @@ -323,12 +342,14 @@ cc_int_context_new_ccache_iterator( cc_context_t context, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ctx_new_ccache_iterator_resp_t*)response->header; - code = cc_int_ccache_iterator_new(iterator, int_context->handle, response_header->iterator); + code = cc_int_ccache_iterator_new(iterator, int_context->handle, + ntohll(response_header->iterator)); } else { code = ccErrBadInternalMessage; } @@ -342,13 +363,14 @@ cc_int_context_open_ccache( cc_context_t context, const char* name, cc_ccache_t* ccache ) { - cc_uint32 blob_pos; - cc_int_context_t int_context; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ccache_open_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ccache_open_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || name == NULL || ccache == NULL ) return ccErrBadParam; @@ -362,7 +384,7 @@ cc_int_context_open_ccache( cc_context_t context, if (request_header == NULL) return ccErrNoMem; - code = cci_msg_new(ccmsg_CCACHE_OPEN, &request); + code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN, &request); if (code != ccNoError) { free(request_header); return code; @@ -375,20 +397,21 @@ cc_int_context_open_ccache( cc_context_t context, return code; } - request_header->ctx = int_context->handle; - request_header->name_offset = blob_pos; - request_header->name_len = strlen(name) + 1; + request_header->ctx = htonll(int_context->handle); + request_header->name_offset = htonl(blob_pos); + request_header->name_len = htonl(strlen(name) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_open_resp_t*)response->header; - code = cc_cache_new(ccache, response_header->ccache); + code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -401,12 +424,13 @@ cc_int32 cc_int_context_open_default_ccache( cc_context_t context, cc_ccache_t* ccache) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ccache_open_default_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ccache_open_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || ccache == NULL ) return ccErrBadParam; @@ -420,24 +444,25 @@ cc_int_context_open_default_ccache( cc_context_t context, if (request_header == NULL) return ccErrNoMem; - code = cci_msg_new(ccmsg_CCACHE_OPEN_DEFAULT, &request); + code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN_DEFAULT, &request); if (code != ccNoError) { free(request_header); return code; } - request_header->ctx = int_context->handle; + request_header->ctx = htonll(int_context->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_default_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_open_resp_t*)response->header; - code = cc_cache_new(ccache, response_header->ccache); + code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -453,13 +478,14 @@ cc_int_context_create_ccache( cc_context_t context, const char* principal, cc_ccache_t* ccache ) { - cc_uint32 blob_pos; - cc_int_context_t int_context; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ccache_create_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ccache_create_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || name == NULL || cred_vers == 0 || cred_vers > cc_credentials_v4_v5 || @@ -475,7 +501,7 @@ cc_int_context_create_ccache( cc_context_t context, if (request_header == NULL) return ccErrNoMem; - code = cci_msg_new(ccmsg_CCACHE_CREATE, &request); + code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE, &request); if (code != ccNoError) { free(request_header); return code; @@ -488,10 +514,10 @@ cc_int_context_create_ccache( cc_context_t context, return code; } - request_header->ctx = int_context->handle; - request_header->version = cred_vers; - request_header->name_offset = blob_pos; - request_header->name_len = strlen(name) + 1; + request_header->ctx = htonll(int_context->handle); + request_header->version = htonl(cred_vers); + request_header->name_offset = htonl(blob_pos); + request_header->name_len = htonl(strlen(name) + 1); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); if (code != ccNoError) { @@ -499,19 +525,20 @@ cc_int_context_create_ccache( cc_context_t context, free(request_header); return code; } - request_header->principal_offset = blob_pos; - request_header->principal_len = strlen(principal) + 1; + request_header->principal_offset = htonl(blob_pos); + request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response->header; - code = cc_cache_new(ccache, response_header->ccache); + code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -526,13 +553,14 @@ cc_int_context_create_default_ccache( cc_context_t context, const char* principal, cc_ccache_t* ccache ) { - cc_uint32 blob_pos; - cc_int_context_t int_context; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ccache_create_default_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ccache_create_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || cred_vers == 0 || cred_vers > cc_credentials_v4_v5 || @@ -548,14 +576,14 @@ cc_int_context_create_default_ccache( cc_context_t context, if (request_header == NULL) return ccErrNoMem; - code = cci_msg_new(ccmsg_CCACHE_CREATE_DEFAULT, &request); + code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_DEFAULT, &request); if (code != ccNoError) { free(request_header); return code; } - request_header->ctx = int_context->handle; - request_header->version = cred_vers; + request_header->ctx = htonll(int_context->handle); + request_header->version = htonl(cred_vers); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); if (code != ccNoError) { @@ -563,19 +591,20 @@ cc_int_context_create_default_ccache( cc_context_t context, free(request_header); return code; } - request_header->principal_offset = blob_pos; - request_header->principal_len = strlen(principal) + 1; + request_header->principal_offset = htonl(blob_pos); + request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_default_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response->header; - code = cc_cache_new(ccache, response_header->ccache); + code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -590,13 +619,14 @@ cc_int_context_create_new_ccache( cc_context_t context, const char* principal, cc_ccache_t* ccache ) { - cc_uint32 blob_pos; - cc_int_context_t int_context; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ccache_create_unique_t *request_header; - cc_msg_t *response; + cc_msg_t *response; ccmsg_ccache_create_resp_t *response_header; - cc_int32 code; + cc_uint32 type; + cc_int32 code; if ( context == NULL || cred_vers == 0 || cred_vers > cc_credentials_v4_v5 || @@ -612,14 +642,14 @@ cc_int_context_create_new_ccache( cc_context_t context, if (request_header == NULL) return ccErrNoMem; - code = cci_msg_new(ccmsg_CCACHE_CREATE_UNIQUE, &request); + code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_UNIQUE, &request); if (code != ccNoError) { free(request_header); return code; } - request_header->ctx = int_context->handle; - request_header->version = cred_vers; + request_header->ctx = htonll(int_context->handle); + request_header->version = htonl(cred_vers); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); if (code != ccNoError) { @@ -627,19 +657,20 @@ cc_int_context_create_new_ccache( cc_context_t context, free(request_header); return code; } - request_header->principal_offset = blob_pos; - request_header->principal_len = strlen(principal) + 1; + request_header->principal_offset = htonl(blob_pos); + request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_unique_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = htonl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response-> header; - code = cc_cache_new(ccache, response_header->ccache); + code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -653,14 +684,16 @@ cc_int_context_lock( cc_context_t context, cc_uint32 lock_type, cc_uint32 block ) { - cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_lock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_context_t int_context; + cc_msg_t *request; + ccmsg_ctx_lock_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( context == NULL || - (lock_type != cc_lock_read && lock_type != cc_lock_write) || + (lock_type != cc_lock_read && lock_type != cc_lock_write && + lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) || (block != cc_lock_block && block != cc_lock_noblock) ) return ccErrBadParam; @@ -679,19 +712,20 @@ cc_int_context_lock( cc_context_t context, return code; } - request_header->ctx = int_context->handle; - request_header->lock_type; + request_header->ctx = htonll(int_context->handle); + request_header->lock_type = htonl(lock_type); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_lock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); // TODO: if (block == cc_lock_block) ..... - } else if (response->type == ccmsg_ACK) { + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -704,11 +738,12 @@ cc_int_context_lock( cc_context_t context, cc_int32 cc_int_context_unlock( cc_context_t context ) { - cc_int_context_t int_context; - cc_msg_t *request; + cc_int_context_t int_context; + cc_msg_t *request; ccmsg_ctx_unlock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( context == NULL ) return ccErrBadParam; @@ -728,16 +763,17 @@ cc_int_context_unlock( cc_context_t context ) return code; } - request_header->ctx = int_context->handle; + request_header->ctx = htonll(int_context->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_unlock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -754,20 +790,21 @@ cc_int_context_clone( cc_context_t inContext, cc_int32* supportedVersion, char const** vendor ) { - cc_int_context_t int_context, new_context; - static char vendor_st[128] = ""; - cc_msg_t *request; - ccmsg_clone_t *request_header; - cc_msg_t *response; - ccmsg_clone_resp_t *response_header; - cc_int32 code; + cc_int_context_t int_context, new_context; + static char vendor_st[128] = ""; + cc_msg_t *request; + ccmsg_ctx_clone_t *request_header; + cc_msg_t *response; + ccmsg_ctx_clone_resp_t *response_header; + cc_uint32 type; + cc_int32 code; if ( inContext == NULL || outContext == NULL || supportedVersion == NULL ) return ccErrBadParam; - int_context = (cc_int_context_t)context; + int_context = (cc_int_context_t)inContext; if ( int_context->magic != CC_CONTEXT_MAGIC ) return ccErrInvalidContext; @@ -775,20 +812,21 @@ cc_int_context_clone( cc_context_t inContext, if ((requestedVersion != ccapi_version_2) && (requestedVersion != ccapi_version_3) && (requestedVersion != ccapi_version_4) && - (requestedVersion != ccapi_version_5)) { + (requestedVersion != ccapi_version_5) && + (requestedVersion != ccapi_version_6)) { if (supportedVersion != NULL) { - *supportedVersion = ccapi_version_5; + *supportedVersion = ccapi_version_max; } return ccErrBadAPIVersion; } - request_header = (ccmsg_clone_t*)malloc(sizeof(ccmsg_clone_t)); + request_header = (ccmsg_ctx_clone_t*)malloc(sizeof(ccmsg_ctx_clone_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_context->handle; - request_header->in_version = requestedVersion; + request_header->ctx = htonll(int_context->handle); + request_header->in_version = htonl(requestedVersion); code = cci_msg_new(ccmsg_INIT, &request); if (code != ccNoError) { @@ -796,21 +834,22 @@ cc_int_context_clone( cc_context_t inContext, return code; } - code = cci_msg_add_header(request, request_header, sizeof(ccmsg_init_t)); + code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_clone_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { - response_header = (ccmsg_clone_resp_t *)response->header; - *supportedVersion = response_header->out_version; - code = cc_int_context_new(outContext, response_header->out_ctx, response_header->out_version); + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { + response_header = (ccmsg_ctx_clone_resp_t *)response->header; + *supportedVersion = ntohl(response_header->out_version); + code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), nthol(response_header->out_version)); if (!vendor_st[0]) { char * string; - code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string); + code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string); strncpy(vendor_st, string, sizeof(vendor_st)-1); vendor_st[sizeof(vendor_st)-1] = '\0'; free(string); diff --git a/src/lib/ccapi/client/context.h b/src/lib/ccapi/client/context.h index cd5ca678d4..6ff113a269 100644 --- a/src/lib/ccapi/client/context.h +++ b/src/lib/ccapi/client/context.h @@ -66,7 +66,7 @@ cc_int_context_release( cc_context_t context ); cc_int32 cc_int_context_get_change_time( cc_context_t context, - cc_time_t* time); + cc_time* time); cc_int32 cc_int_context_get_default_ccache_name( cc_context_t context, diff --git a/src/lib/ccapi/client/credentials.c b/src/lib/ccapi/client/credentials.c index b0a3df2b75..8b88676892 100644 --- a/src/lib/ccapi/client/credentials.c +++ b/src/lib/ccapi/client/credentials.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -159,23 +159,23 @@ cc_int_credentials_release( cc_credentials_t creds ) cc_int32 cc_int_credentials_compare( cc_credentials_t credentials, - cc_credentials_t compare_to, - cc_uint32* equal ) + cc_credentials_t compare_to, + cc_uint32* equal ) { cc_int_credentials_t int_credentials; cc_int_credentials_t int_compare_to; if ( credentials == NULL || compare_to == NULL || equal == NULL ) return ccErrBadParam; - + int_credentials = (cc_int_credentials_t)credentials; + int_compare_to = (cc_int_credentials_t)compare_to; + if ( int_credentials->magic != CC_CREDS_MAGIC || int_compare_to->magic != CC_CREDS_MAGIC ) return ccErrInvalidCredentials; - int_credentials = (cc_int_credentials_t)credentials; - int_compare_to = (cc_int_credentials_t)compare_to; - *equal = (int_credentials->handle == int_compare_to->handle); + return ccNoError; } diff --git a/src/lib/ccapi/client/credentials.h b/src/lib/ccapi/client/credentials.h index 320c618257..dfd589f326 100644 --- a/src/lib/ccapi/client/credentials.h +++ b/src/lib/ccapi/client/credentials.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -84,8 +84,8 @@ cci_creds_v5_marshall( cc_credentials_v5_t * creds, cc_int32 cci_creds_v4_unmarshall( char * flat, - cc_uint32 len, - cc_credentials_union * creds); + cc_uint32 len, + cc_credentials_union * creds); cc_int32 cci_creds_v5_unmarshall( char * flat, diff --git a/src/lib/ccapi/client/credentials_iterator.c b/src/lib/ccapi/client/credentials_iterator.c index b7333daf30..bae60ffdf0 100644 --- a/src/lib/ccapi/client/credentials_iterator.c +++ b/src/lib/ccapi/client/credentials_iterator.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,6 +47,7 @@ #include #include #include "credentials_iterator.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" @@ -74,6 +75,7 @@ cc_int_credentials_iterator_new( cc_credentials_iterator_t * piter, iter->functions->release = cc_int_credentials_iterator_release; iter->functions->next = cc_int_credentials_iterator_next; + iter->functions->clone = cc_int_credentials_iterator_clone; iter->magic = CC_CREDS_ITER_MAGIC; iter->ctx = ctx; iter->ccache = ccache; @@ -87,10 +89,11 @@ cc_int32 cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) { cc_int_credentials_iterator_t int_iter; - cc_msg_t *request; + cc_msg_t *request; ccmsg_creds_iterator_release_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( iter == NULL ) return ccErrBadParam; @@ -103,9 +106,10 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) request_header = (ccmsg_creds_iterator_release_t*)malloc(sizeof(ccmsg_creds_iterator_release_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_iter->ctx; - request_header->ccache = int_iter->ccache; - request_header->iterator = int_iter->handle; + request_header->ctx = htonll(int_iter->ctx); + request_header->ccache = htonll(int_iter->ccache); + request_header->iterator = htonll(int_iter->handle); + code = cci_msg_new(ccmsg_CREDS_ITERATOR_RELEASE, &request); if (code != ccNoError) { free(request_header); @@ -116,10 +120,11 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = htonl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = htonl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -137,10 +142,11 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, cc_credentials_t * credentials ) { cc_int_credentials_iterator_t int_iter; - cc_msg_t *request; + cc_msg_t *request; ccmsg_creds_iterator_next_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( credentials == NULL ) return ccErrBadParam; @@ -153,9 +159,9 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, request_header = (ccmsg_creds_iterator_next_t*)malloc(sizeof(ccmsg_creds_iterator_next_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_iter->ctx; - request_header->ccache = int_iter->ccache; - request_header->iterator = int_iter->handle; + request_header->ctx = htonll(int_iter->ctx); + request_header->ccache = htonll(int_iter->ccache); + request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CREDS_ITERATOR_NEXT, &request); if (code != ccNoError) { @@ -167,16 +173,17 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * blob; ccmsg_creds_iterator_next_resp_t * response_header = (ccmsg_creds_iterator_next_resp_t*)response->header; - code = cci_msg_retrieve_blob(response, response_header->creds_offset, response_header->creds_len, &blob); - code = cc_credentials_new(credentials, response_header->version, - int_iter->ctx, int_iter->ccache, response_header->creds_handle, - blob, response_header->creds_len); + code = cci_msg_retrieve_blob(response, ntohl(response_header->creds_offset), ntohl(response_header->creds_len), &blob); + code = cc_int_credentials_new(credentials, ntohl(response_header->version), + int_iter->ctx, int_iter->ccache, ntohll(response_header->creds_handle), + blob, ntohl(response_header->creds_len)); free(blob); } else { code = ccErrBadInternalMessage; @@ -185,3 +192,54 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, cci_msg_destroy(response); return code; } + +cc_int32 +cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter, + cc_credentials_iterator_t* new_iter) +{ + cc_int_credentials_iterator_t int_iter; + cc_msg_t *request; + ccmsg_creds_iterator_clone_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; + + if ( iter == NULL || new_iter == NULL ) + return ccErrBadParam; + + int_iter = (cc_int_credentials_iterator_t)iter; + + if ( int_iter->magic != CC_CREDS_ITER_MAGIC ) + return ccErrInvalidCCacheIterator; + + request_header = (ccmsg_creds_iterator_clone_t*)malloc(sizeof(ccmsg_creds_iterator_clone_t)); + if (request_header == NULL) + return ccErrNoMem; + request_header->ctx = htonll(int_iter->ctx); + request_header->iterator = htonll(int_iter->handle); + + code = cci_msg_new(ccmsg_CREDS_ITERATOR_CLONE, &request); + if (code != ccNoError) { + free(request_header); + return code; + } + + code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_clone_t)); + + code = cci_perform_rpc(request, &response); + + type = ntohl(response->type); + if (type == ccmsg_NACK) { + ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { + ccmsg_creds_iterator_clone_resp_t * response_header = (ccmsg_creds_iterator_clone_resp_t*)response->header; + code = cc_int_credentials_iterator_new(new_iter, int_iter->ctx, int_iter->ccache, ntohll(response_header->iterator)); + } else { + code = ccErrBadInternalMessage; + } + cci_msg_destroy(request); + cci_msg_destroy(response); + return code; +} + diff --git a/src/lib/ccapi/client/credentials_iterator.h b/src/lib/ccapi/client/credentials_iterator.h index 2a6f8edf2d..954d2f1afa 100644 --- a/src/lib/ccapi/client/credentials_iterator.h +++ b/src/lib/ccapi/client/credentials_iterator.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -69,4 +69,8 @@ cc_int32 cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, cc_credentials_t * credentials ); +cc_int32 +cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter, + cc_credentials_iterator_t * new_iter ); + diff --git a/src/lib/ccapi/client/marshall.c b/src/lib/ccapi/client/marshall.c new file mode 100644 index 0000000000..31ebacd7b9 --- /dev/null +++ b/src/lib/ccapi/client/marshall.c @@ -0,0 +1,445 @@ +/* $Copyright: + * + * Copyright 2004-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ + +/* marshall.c */ + +#include +#include +#include +#include "msg.h" +#include "msg_headers.h" +#include "marshall.h" + +cc_int32 +cci_creds_v4_marshall( cc_credentials_v4_t * creds, + char ** pflat, + cc_uint32 * plen) +{ + cc_uint32 len; + char * flat; + cci_flat_creds_v4_t * header; + cc_uint32 length; + cc_time64 t64; + + if ( creds == NULL || pflat == NULL || plen == NULL ) + return ccErrBadParam; + + len = sizeof(cci_flat_creds_v4_t); + flat = (char *)malloc(len); + if ( flat == NULL ) + return ccErrNoMem; + memset(flat, 0, len); + + header = (cci_flat_creds_v4_t *)flat; + header->version = htonl(creds->version); + memcpy(header->principal, creds->principal, cc_v4_name_size); + memcpy(header->principal_instance, creds->principal_instance, cc_v4_instance_size); + memcpy(header->service, creds->service, cc_v4_name_size); + memcpy(header->service_instance, creds->service_instance, cc_v4_instance_size); + memcpy(header->realm, creds->realm, cc_v4_realm_size); + memcpy(header->session_key, creds->session_key, cc_v4_key_size); + header->kvno = htonl(creds->kvno); + header->string_to_key_type = htonl(creds->string_to_key_type); + t64 = creds->issue_date; + header->issue_date = htonll(t64); + header->lifetime = htonl(creds->lifetime); + /* TODO: verify that address is stored in host order */ + header->address = htonl(creds->address); + header->ticket_size = htonl(creds->ticket_size); + memcpy(header->ticket, creds->ticket, cc_v4_ticket_size); + + *pflat = flat; + *plen = len; + + return ccNoError; +} + +cc_int32 +cci_creds_v4_unmarshall( char * flat, + cc_uint32 len, + cc_credentials_union * creds_union) +{ + struct cci_flat_creds_v4 * header; + cc_credentials_v4_t * creds; + cc_flat_data * flat_data; + cc_time64 t64; + cc_uint32 length; + cc_int32 code; + + if ( flat == NULL || len == 0 || creds_union == NULL ) + return ccErrBadParam; + + creds_union->version = cc_credentials_v4; + + header = (cci_flat_creds_v4_t *)flat; + + creds = (cc_credentials_v4_t *)malloc(sizeof(cc_credentials_v4_t)); + if ( creds == NULL ) + return ccErrNoMem; + + creds->version = ntohl(header->version); + memcpy(creds->principal, header->principal, cc_v4_name_size); + memcpy(creds->principal_instance, header->principal_instance, cc_v4_instance_size); + memcpy(creds->service, header->service, cc_v4_name_size); + memcpy(creds->service_instance, header->service_instance, cc_v4_instance_size); + memcpy(creds->realm, header->realm, cc_v4_realm_size); + memcpy(creds->session_key, header->session_key, cc_v4_key_size); + creds->kvno = htonl(header->kvno); + creds->string_to_key_type = htonl(header->string_to_key_type); + t64 = header->issue_date; + creds->issue_date = ntohll(t64); + creds->lifetime = ntohl(header->lifetime); + /* TODO: verify that address is stored in host order */ + creds->address = ntohl(header->address); + creds->ticket_size = ntohl(header->ticket_size); + memcpy(creds->ticket, header->ticket, cc_v4_ticket_size); + + creds_union->credentials.credentials_v4 = creds; + + return ccNoError; +} + + +cc_int32 +cci_creds_cc_data_array_count_entries( cc_data ** array, cc_uint32 * pcount) +{ + cc_uint32 count; + + if (array == NULL) { + *pcount = 0; + return ccNoError; + } + + for ( count=0; array[count] != NULL ; count++) ; + + *pcount = count; + return ccNoError; +} + +cc_int32 +cci_creds_v5_compute_flat_size( cc_credentials_v5_t * creds, cc_uint32 * plen) +{ + cc_uint32 len; + cc_uint32 i, count; + + len = sizeof(struct cci_flat_creds_v5); + + if (creds->client) + len += strlen(creds->client) + 1; + + if (creds->server) + len += strlen(creds->server) + 1; + + len += creds->keyblock.length; + + cci_creds_cc_data_array_count_entries( creds->addresses, &count ); + len += count * sizeof(cc_flat_data); + for ( i=0; iaddresses[i]->length; + } + + len += creds->ticket.length; + len += creds->second_ticket.length; + + cci_creds_cc_data_array_count_entries( creds->authdata, &count ); + len += count * sizeof(cc_flat_data); + for ( i=0; iauthdata[i]->length; + } + + *plen = len; + return ccNoError; +} + +cc_int32 +cci_creds_v5_marshall( cc_credentials_v5_t * creds, + char ** pflat, + cc_uint32 * plen) +{ + cc_uint32 len; + char * flat; + struct cci_flat_creds_v5 * header; + cc_uint32 length; + cc_uint32 offset; + cc_time64 t64; + cc_uint32 count; + cc_uint32 i; + + if ( creds == NULL || pflat == NULL || plen == NULL ) + return ccErrBadParam; + + cci_creds_v5_compute_flat_size(creds, &len); + + flat = (char *)malloc(len); + if ( flat == NULL ) + return ccErrNoMem; + memset(flat, 0, len); + + offset = sizeof(struct cci_flat_creds_v5); + header = (struct cci_flat_creds_v5 *)flat; + header->version = htonl(FLAT_CREDS_V5_VERSION); + if (creds->client) { + length = strlen(creds->client) + 1; + header->client.length = htonl(length); + header->client.data = htonl(offset); + memcpy(flat + offset, creds->client, length); + offset += length; + } + + if (creds->server) { + length = strlen(creds->server) + 1; + header->server.length = htonl(length); + header->server.data = htonl(offset); + memcpy(flat + offset, creds->server, length); + offset += length; + } + + header->keyblock.type = htonl(creds->keyblock.type); + if (creds->keyblock.length) { + length = creds->keyblock.length; + header->keyblock.length = htonl(length); + header->keyblock.data = htonl(offset); + memcpy(flat + offset, creds->keyblock.data, length); + offset += length; + } + + t64 = creds->authtime; + header->authtime = htonll(t64); + t64 = creds->starttime; + header->starttime = htonll(t64); + t64 = creds->endtime; + header->endtime = htonll(t64); + t64 = creds->renew_till; + header->renew_till = htonll(t64); + + header->is_skey = htonl(creds->is_skey); + header->ticket_flags = htonl(creds->ticket_flags); + + cci_creds_cc_data_array_count_entries( creds->addresses, &count ); + if ( count ) { + cc_flat_data * addresses = (cc_flat_data *)flat + offset; + header->address_count = htonl(count); + header->addresses = htonl(offset); + offset += count * sizeof(cc_flat_data); + + for ( i=0; i < count; i++ ) { + addresses[i].type = htonl(creds->addresses[i]->type); + if (creds->addresses[i]->length) { + length = creds->addresses[i]->length; + addresses[i].length = htonl(length); + addresses[i].data = htonl(offset); + /* TODO: verify that addresses are stored in network order */ + memcpy(flat + offset, creds->addresses[i]->data, length); + offset += length; + } + } + } + + header->ticket.type = htonl(creds->ticket.type); + if (creds->ticket.length) { + length = creds->ticket.length; + header->ticket.length = htonl(length); + header->ticket.data = htonl(offset); + memcpy(flat + offset, creds->ticket.data, length); + offset += length; + } + + header->second_ticket.type = htonl(creds->second_ticket.type); + if (creds->second_ticket.length) { + length = creds->second_ticket.length; + header->second_ticket.length = htonl(length); + header->second_ticket.data = htonl(offset); + memcpy(flat + offset, creds->second_ticket.data, length); + offset += length; + } + + cci_creds_cc_data_array_count_entries( creds->authdata, &count ); + if ( count ) { + cc_flat_data * authdata = (cc_flat_data *)flat + offset; + + header->authdata_count = htonl(count); + header->authdata = (offset); + offset += count * sizeof(cc_flat_data); + + for ( i=0; i < count; i++ ) { + authdata[i].type = htonl(creds->authdata[i]->type); + if (creds->authdata[i]->length) { + length = creds->authdata[i]->length; + authdata[i].length = htonl(length); + authdata[i].data = htonl(offset); + memcpy(flat + offset, creds->authdata[i]->data, length); + offset += length; + } + } + } + + *pflat = flat; + *plen = len; + return ccNoError; +} + + +// TODO: a much better job of checking for out of memory errors +// and validating that we do not read beyond the flat input +// data buffer + +cc_int32 +cci_creds_v5_unmarshall( char * flat, + cc_uint32 len, + cc_credentials_union * creds_union) +{ + struct cci_flat_creds_v5 * header; + cc_credentials_v5_t * creds; + cc_flat_data * flat_data; + cc_time64 t64; + cc_uint32 length; + cc_uint32 count; + cc_uint32 i; + cc_int32 code; + + if ( flat == NULL || len == 0 || creds_union == NULL ) + return ccErrBadParam; + + creds_union->version = cc_credentials_v5; + + header = (struct cci_flat_creds_v5 *)flat; + + if ( ntohl(header->version) != FLAT_CREDS_V5_VERSION ) + return ccErrBadParam; + + creds = (cc_credentials_v5_t *)malloc(sizeof(cc_credentials_v5_t)); + if ( creds == NULL ) + return ccErrNoMem; + memset(creds, 0, sizeof(cc_credentials_v5_t)); + + if ( header->client.length ) { + length = ntohl(header->client.length); + creds->client = (char *)malloc(length); + memcpy(creds->client, flat + header->client.data, length); + } + + if ( header->server.length ) { + length = ntohl(header->server.length); + creds->server = (char *)malloc(length); + memcpy(creds->server, flat + header->server.data, length); + } + + creds->keyblock.type = ntohl(header->keyblock.type); + if ( header->keyblock.length ) { + length = ntohl(header->keyblock.length); + creds->keyblock.length = length; + creds->keyblock.data = malloc(length); + memcpy(creds->keyblock.data, flat + header->keyblock.data, length); + } + + /* TODO: need to perform overflow validation checks to ensure + * that we do not attempt to store too large a value into cc_time_t + * when it is a 32-bit field. + */ + t64 = ntohll(header->authtime); + creds->authtime = (cc_time)t64; + t64 = ntohll(header->starttime); + creds->starttime = (cc_time)t64; + t64 = ntohll(header->endtime); + creds->endtime = (cc_time)t64; + t64 = ntohll(header->renew_till); + creds->renew_till = (cc_time)t64; + + creds->is_skey = ntohl(header->is_skey); + creds->ticket_flags = ntohl(header->ticket_flags); + + count = ntohl(header->address_count); + creds->addresses = (cc_data **) malloc((count + 1) * sizeof(cc_data *)); + flat_data = (cc_flat_data *)flat + header->addresses; + for ( i=0 ; i < count ; i++ ) { + creds->addresses[i] = (cc_data *)malloc(sizeof(cc_data)); + creds->addresses[i]->type = ntohl(flat_data[i].type); + length = ntohl(flat_data[i].length); + creds->addresses[i]->length = length; + if ( length ) { + creds->addresses[i]->data = malloc(length); + /* TODO: verify that addresses are stored in network order */ + memcpy(creds->addresses[i]->data, flat + flat_data[i].data, length); + } else { + creds->addresses[i]->data = NULL; + } + } + creds->addresses[i] = NULL; + + creds->ticket.type = ntohl(header->ticket.type); + length = ntohl(header->ticket.length); + if ( length ) { + creds->ticket.length = length; + creds->ticket.data = malloc(length); + memcpy(creds->ticket.data, flat + header->ticket.data, length); + } + + creds->second_ticket.type = header->second_ticket.type; + if ( header->second_ticket.length ) { + creds->second_ticket.length = header->second_ticket.length; + creds->second_ticket.data = malloc(creds->second_ticket.length); + memcpy(creds->second_ticket.data, flat + header->second_ticket.data, creds->second_ticket.length); + } + + count = ntohl(header->authdata_count); + creds->authdata = (cc_data **) malloc((count + 1) * sizeof(cc_data *)); + flat_data = (cc_flat_data *)flat + header->authdata; + for ( i=0 ; i < count ; i++ ) { + creds->authdata[i] = (cc_data *)malloc(sizeof(cc_data)); + creds->authdata[i]->type = ntohl(flat_data[i].type); + length = ntohl(flat_data[i].length); + creds->authdata[i]->length = length; + if ( length ) { + creds->authdata[i]->data = malloc(length); + memcpy(creds->authdata[i]->data, flat + flat_data[i].data, length); + } else { + creds->authdata[i]->data = NULL; + } + } + creds->authdata[i] = NULL; + + creds_union->credentials.credentials_v5 = creds; + + return ccNoError; +} + diff --git a/src/lib/ccapi/client/msg.c b/src/lib/ccapi/client/msg.c new file mode 100644 index 0000000000..facaffffcc --- /dev/null +++ b/src/lib/ccapi/client/msg.c @@ -0,0 +1,628 @@ +/* $Copyright: + * + * Copyright 2004-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ + +/* + * Verifiable, extensible message format. + * + * Format: + * + * + * + * + * + * + * + * + * + * ... + * + * + * If the header has variable length data it is included in the data blobs. + * The header field has the offset from the beginning of the message of the 1st + * byte of the data and the length of the data. + */ + +#include "CredentialsCache.h" +#include "msg.h" +#include "generic_lists.h" + +#include +#include +#include +#include + +/** + * cci_msg_new() + * + * Purpose: Allocate and initialize a new cc_msg_t structure + * + * Input parameter (type) in host order + * + * Return: non-NULL, the msg + * NULL, failure + * + * Errors: ccErrNoMem + * + */ +cc_int32 +cci_msg_new(cc_uint32 type, cc_msg_t** msgpp) +{ + // type should be validated. If invalid set error to ccErrBadParam + cc_msg_t* msg; + + if ( type > CC_MSG_MAX_TYPE || msgpp == NULL ) + return ccErrBadParam; + + msg = (cc_msg_t*)malloc(sizeof(cc_msg_t)); + if (msg == NULL) + return ccErrNoMem; + + msg->type = htonl(type); + msg->flat = NULL; + msg->header = NULL; + msg->flat_len = 0; + msg->header_len = 0; + msg->magic = 0; + cci_generic_list_new(&msg->data_blobs); + if (msg->data_blobs == NULL) { + // pass on error from previous call + free(msg); + return ccErrNoMem; + } + + *msgpp = msg; + return ccNoError; +} + +/** + * cci_msg_calc_header_size() + * + * Purpose: Calculates the size of the header + * + * Return: the size in bytes + * + * Errors: ccErrBadParam + * + */ +cc_int32 +cci_msg_calc_header_size(cc_msg_t* msg, cc_uint32 * lenp) +{ + int header_len = 12; /* header size, entire size, type */ + + if ( msg == NULL || lenp == NULL ) + return ccErrBadParam; + + header_len += msg->header_len; + *lenp = header_len; + return ccNoError; +} + +/** + * cci_msg_calc_size() + * + * Purpose: Calculates the size of the message + * (does not include the magic bytes) + * + * Return: the size in bytes + * + * Errors: ccErrBadParam + * + */ +cc_int32 +cci_msg_calc_size(cc_msg_t* msg, cc_uint32 * lenp) +{ + cc_uint32 flat_len; + cc_generic_list_node_t* gen_node; + cc_generic_iterate_t* gen_iterator; + cc_int32 code; + + if ( msg == NULL || lenp == NULL ) + return ccErrBadParam; + + code = cci_msg_calc_header_size(msg, &flat_len); + if (code != ccNoError) + goto bad; + + code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator); + if ( code != ccNoError ) + goto bad; + + while (cci_generic_iterate_has_next(gen_iterator)) { + code = cci_generic_iterate_next(gen_iterator, &gen_node); + if (code != ccNoError) + break; + flat_len += gen_node->len + BLOB_LEN; + } + cci_generic_free_iterator(gen_iterator); + if (code != ccNoError) + goto bad; + + flat_len += MAGIC_HEAD_LEN + MAGIC_DATA_LEN; + *lenp = flat_len; + + bad: + return code; +} + +/** + * cci_msg_add_data_blob() + * + * Purpose: Adds 'len' bytes of data to the msg + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_add_data_blob(cc_msg_t* msg, void *data, cc_uint32 len, cc_uint32 *lenp) +{ + cc_int32 code; + + if (msg == NULL || data == NULL || len <= 0 || lenp == NULL) + return ccErrBadParam; + + code = cci_generic_list_append(msg->data_blobs, data, len, NULL); + if ( code != ccNoError ) + return code; + return cci_msg_calc_blob_pos(msg, data, len, lenp); +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_calc_blob_pos(cc_msg_t* msg, void *data, cc_uint32 len, cc_uint32 * posp) +{ + cc_uint32 pos; + cc_generic_list_node_t* gen_node; + cc_generic_iterate_t* gen_iterator; + cc_int32 code; + + code = cci_msg_calc_header_size(msg, &pos); + pos += sizeof(cc_uint32); /*+ sizeof(cc_uint32) for magic*/ + + code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator); + while (cci_generic_iterate_has_next(gen_iterator)) { + code = cci_generic_iterate_next(gen_iterator, &gen_node); + if (gen_node->len != len && gen_node->data != data) { + pos += gen_node->len + sizeof(cc_uint32); + } else { + cci_generic_free_iterator(gen_iterator); + *posp = pos + sizeof(cc_uint32); + return ccNoError; + } + } + + cci_generic_free_iterator(gen_iterator); + return ccIteratorEnd; +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_add_header(cc_msg_t* msg, void *header, cc_uint32 header_len) +{ + if ( msg == NULL || header == NULL ) + return ccErrBadParam; + + msg->header = header; + msg->header_len = header_len; + return ccNoError; +} + + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_flatten(cc_msg_t* msg, void **flatpp) +{ + cc_generic_list_node_t* gen_node; + cc_generic_iterate_t* gen_iterator; + char *cur_pos; + cc_uint32 zero = 0; + cc_uint32 magic = 0; + cc_uint32 msg_len; + cc_uint32 u32; + cc_int32 code; + + if (msg == NULL || flatpp == NULL) + return ccErrBadParam; + + code = cci_msg_calc_size(msg,&msg->flat_len); + if ( code != ccNoError ) + return code; + + if (msg->flat_len > CC_MSG_MAX_SIZE) + return ccErrBadParam; + + msg->flat = (void *)malloc(msg->flat_len); + if (msg->flat == NULL) + return ccErrNoMem; + + cur_pos = msg->flat; + + u32 = msg->header_len; + htonl(u32); + memcpy(cur_pos,&u32,sizeof(cc_uint32)); + cur_pos+=sizeof(cc_uint32); + + u32 = msg->flat_len; + htonl(u32); + memcpy(cur_pos,&u32,sizeof(cc_uint32)); + cur_pos+=sizeof(cc_uint32); + + u32 = msg->type; + htonl(u32); + memcpy(cur_pos,&u32,sizeof(cc_uint32)); + cur_pos+=sizeof(cc_uint32); + + /* header data is already in network order */ + memcpy(cur_pos, msg->header, msg->header_len); + cur_pos += msg->header_len; + + u32 = zero; + htonl(zero); + memcpy(cur_pos, &u32, sizeof(cc_uint32)); /*will be magic number later*/ + cur_pos += sizeof(cc_uint32); + + code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator); + if ( code != ccNoError ) { + free(msg->flat); + return code; + } + + while (cci_generic_iterate_has_next(gen_iterator)) { + code = cci_generic_iterate_next(gen_iterator, &gen_node); + if (code != ccNoError) { + free(gen_iterator); + free(msg->flat); + return code; + } + u32 = gen_node->len; + htonl(u32); + memcpy(cur_pos, &u32, sizeof(cc_uint32)); + cur_pos+=sizeof(cc_uint32); + + /* data already in network order */ + memcpy(cur_pos, gen_node->data, gen_node->len); + cur_pos += gen_node->len; + } + free(gen_iterator); + + u32 = zero; + htonl(zero); + memcpy(cur_pos, &u32, sizeof(cc_uint32)); /*magic number will go here later*/ + cur_pos += sizeof(cc_uint32); + + if (cur_pos - (char *)msg->flat != msg->flat_len) { + fprintf(stderr, "ERROR cur_pos - msg->flat = %d\n",msg->flat_len); + } + + cci_msg_calc_magic(msg->flat, msg->flat_len, &magic); + printf("magic = %d\n",magic); + + cci_msg_calc_header_size(msg, &msg_len); + memcpy((char *)msg->flat + msg_len, &magic, sizeof(cc_uint32)); + memcpy((char *)msg->flat + msg->flat_len - sizeof(cc_uint32), &magic, sizeof(cc_uint32)); + + if ( flatpp != NULL ) + *flatpp = msg->flat; + + return ccNoError; +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_calc_magic(void *flat, int flat_len, cc_uint32 * magicp) +{ + cc_uint32 magic = 0; + int i; + + for (i = 0; i < flat_len; i += sizeof(cc_uint32)) { + magic = magic ^ *(int *)((char *)flat + i); + } + *magicp = htonl(magic); + return ccNoError; +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_verify(void *flat, int flat_len, cc_uint32 * validp) +{ + cc_uint32 *magic1, *magic2; + cc_uint32 *pheader_len; + cc_uint32 header_len; + cc_uint32 *ptotal_len; + cc_uint32 total_len; + cc_uint32 *pblob_len; + cc_uint32 blob_len; + cc_uint32 *ptype; + cc_uint32 type; + cc_uint32 num_blobs = 0; + cc_uint32 zero = 0; + cc_uint32 msg_magic, msg_magic2; + + if (flat == NULL || flat_len <= 0 || validp == NULL) + return ccErrBadParam; + + pheader_len = flat; + ptotal_len = (cc_uint32 *)((char *)pheader_len + sizeof(cc_uint32)); + ptype = (cc_uint32 *)((char *)ptotal_len + sizeof(cc_uint32)); + + header_len = ntohl(*pheader_len); + total_len = ntohl(*ptotal_len); + type = ntohl(*ptype); + + if (total_len != flat_len) { + *validp = 0; + return ccNoError; + } + + if (header_len > flat_len) { + /*too weak. We could verify header_len against type spec header.*/ + *validp = 0; + return ccNoError; + } + if (type > CC_MSG_MAX_TYPE) { + *validp = 0; + return ccNoError; + } + + magic1 = (cc_uint32 *)((char *)ptype + sizeof(cc_uint32) + header_len); + if ((char *)magic1 - (char *)flat == (flat_len - 8)) { + /*There are no data blobs*/ + magic2 = (cc_uint32 *)((char *)magic1 + sizeof(cc_uint32)); + num_blobs = 0; + } else { + pblob_len = (cc_uint32 *)((char *)magic1 + sizeof(cc_uint32)); + num_blobs = 1; + blob_len = nothl(*pblob_len); + + while (blob_len + sizeof(cc_uint32) + ((char *)pblob_len - (char *)flat) < (flat_len - sizeof(cc_uint32))) { + pblob_len = (cc_uint32 *)((char *)pblob_len + blob_len + sizeof(cc_uint32)); + num_blobs++; + blob_len = ntohl(*pblob_len); + } + + if (blob_len + sizeof(cc_uint32) + ((char *)pblob_len - (char *)flat) != (flat_len - sizeof(cc_uint32))) { + /*blobs didn't line up*/ + *validp = 0; + return ccNoError; + } + magic2 = (cc_uint32 *)((char *)pblob_len + blob_len + sizeof(cc_uint32)); /*2nd magic should be directly after the last blob*/ + } + + if (*magic1 != *magic2) { + *validp = 0; + return ccNoError; + } + msg_magic = *magic1; + + printf("%d %d\n", (char *)magic1 - (char *)flat, (char *)magic2 - (char *)flat); + + memcpy(magic1, &zero, sizeof(cc_uint32)); + memcpy(magic2, &zero, sizeof(cc_uint32)); + cci_msg_calc_magic(flat, flat_len, &msg_magic2); + /* both msg_magic and msg_magic2 are in network order */ + if (msg_magic != msg_magic2) { + *validp = 0; + return ccNoError; + } + memcpy(magic1, &msg_magic, sizeof(cc_uint32)); + memcpy(magic2, &msg_magic, sizeof(cc_uint32)); + + *validp = 1; + return ccNoError; +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_unflatten(void *flat, int flat_len, cc_msg_t** msgpp) +{ + cc_msg_t* msg; + char *cur_pos; + cc_uint32 blob_len; + char *blob; + cc_uint32 valid; + cc_int32 code; + + if ( flat == NULL || flat_len <= 0 || msgpp == NULL ) + return ccErrBadParam; + + code = cci_msg_new(0, &msg); + if (code) + return code; + + cci_msg_verify(flat, flat_len, &valid); + if (valid != 1) { + cci_msg_destroy(msg); + return ccErrBadParam; + } + + cur_pos = flat; + msg->flat = flat; + + msg->header_len = ntohl(*(cc_uint32 *)cur_pos); + cur_pos += sizeof(cc_uint32); + + msg->flat_len = ntohl(*(cc_uint32 *)cur_pos); + cur_pos += sizeof(cc_uint32); + + msg->type = ntohl(*(cc_uint32 *)cur_pos); + cur_pos += sizeof(cc_uint32); + + msg->header = (void *)malloc(msg->header_len); + if (msg->header == NULL) { + cci_msg_destroy(msg); + return ccErrNoMem; + } + memcpy(msg->header, cur_pos, msg->header_len); + cur_pos += msg->header_len; + + msg->magic = nothl(*(cc_uint32 *)cur_pos); + cur_pos += sizeof(cc_uint32); + + if (cur_pos - (char *)flat != flat_len - 8) { /*at least 1 blob*/ + blob_len = ntohl(*(cc_uint32 *)cur_pos); + while (blob_len + (cur_pos - (char *)flat) + sizeof(cc_uint32) <= flat_len - sizeof(cc_uint32)) { + blob = (void *)malloc(blob_len); + if (blob == NULL) { + cci_msg_destroy(msg); + return ccErrNoMem; + } + memcpy(blob, cur_pos + sizeof(cc_uint32), blob_len); + cci_generic_list_append(msg->data_blobs, blob, blob_len, NULL); + + cur_pos += sizeof(cc_uint32) + blob_len; + blob_len = ntohl(*(int *)cur_pos); + } + } + *msgpp = msg; + return ccNoError; +} + +cc_int32 +cci_msg_retrieve_blob(cc_msg_t* msg, cc_uint32 blob_offset, cc_uint32 blob_len, void **blobp) +{ + cc_generic_iterate_t* gen_iterator; + cc_generic_list_node_t* gen_node; + void *ret; + cc_uint32 blob_pos; + cc_int32 code; + + /*Ensure that the message has been unflattened*/ + if ( msg == NULL || msg->flat == NULL || blob_offset > msg->flat_len || + blob_len > msg->flat_len - blob_offset || blobp == NULL) + return ccErrBadParam; + + code = cci_generic_list_iterator(msg->data_blobs, &gen_iterator); + while (cci_generic_iterate_has_next(gen_iterator)) { + code = cci_generic_iterate_next(gen_iterator, &gen_node); + code = cci_msg_calc_blob_pos(msg, gen_node->data, gen_node->len, &blob_pos); + if (blob_pos == blob_offset && gen_node->len == blob_len) { + free(gen_iterator); + ret = (void *)malloc(blob_len); + if (ret == NULL) + return ccErrNoMem; + memcpy(ret,(char *)msg->flat + blob_offset, blob_len); + *blobp = ret; + return ccNoError; + } + } + free(gen_iterator); + return ccIteratorEnd; +} + +/** + * cc_msg_ + * + * Purpose: + * + * Return: + * + * Errors: + * + */ +cc_int32 +cci_msg_destroy(cc_msg_t* msg) +{ + if (msg->flat != NULL) + free(msg->flat); + if (msg->header != NULL) + free(msg->flat); + cci_generic_list_destroy(msg->data_blobs); + free(msg); + return ccNoError; +} + -- cgit