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 09ef9df38..57ff87416 100644 --- a/src/lib/ccapi/client/NTMakefile +++ b/src/lib/ccapi/client/NTMakefile @@ -12,11 +12,11 @@ $(CCAPI_LIB): $(CCAPI_OBJS) CCAPI_DLLFILE = krbcc32.dll - - $(CCAPI_DLLFILE): $(CCAPI_LIB) $(DLLGUILINK) -def:windows\krbcc32.def $(DLLPREP) +all: $(CCAPI_DLLFILE) + clean: del *.obj *.lib diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c index 2c874bec0..704925dfd 100644 --- a/src/lib/ccapi/client/cacheapi.c +++ b/src/lib/ccapi/client/cacheapi.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,10 +47,17 @@ #include "ccache.h" #include "ccache_iterator.h" #include "context.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" -cc_int32 +/*! \fn cc_initialize + * \brief A function that initializes a ccapi context for the caller. + * \param[out] outContext a cc_context_t pointer to which is assigned the newly created context upon success. + * \param[in] inVersion a cc_int32 that specifies the + */ + +CCACHE_API cc_int32 cc_initialize ( cc_context_t* outContext, cc_int32 inVersion, cc_int32* outSupportedVersion, @@ -60,16 +67,18 @@ cc_initialize ( cc_context_t* outContext, cc_msg_t *request; ccmsg_init_t *request_header; cc_msg_t *response; + cc_uint32 type; ccmsg_init_resp_t *response_header; cc_int32 code; if ((inVersion != ccapi_version_2) && (inVersion != ccapi_version_3) && (inVersion != ccapi_version_4) && - (inVersion != ccapi_version_5)) { + (inVersion != ccapi_version_5) && + (inVersion != ccapi_version_6)) { if (outSupportedVersion != NULL) { - *outSupportedVersion = ccapi_version_5; + *outSupportedVersion = ccapi_version_6; } return ccErrBadAPIVersion; } @@ -78,7 +87,17 @@ cc_initialize ( cc_context_t* outContext, if (request_header == NULL) return ccErrNoMem; - request_header->in_version = inVersion; + /* If the version number is 2, the caller will be passing + * the structure into the v2 compatibility functions which + * in turn will call the v6 functions. Set the version to + * ccapi_version_max since that is what the compatibility + * functions will be expecting. + */ + if (inVersion == ccapi_version_2) + inVersion = ccapi_version_max; + + /* Construct the request */ + request_header->in_version = htonl(inVersion); code = cci_msg_new(ccmsg_INIT, &request); if (code != ccNoError) { @@ -90,17 +109,18 @@ cc_initialize ( cc_context_t* outContext, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { response_header = (ccmsg_init_resp_t *)response->header; - *outSupportedVersion = response_header->out_version; - code = cc_context_int_new(outContext, response_header->out_ctx, response_header->out_version); + *outSupportedVersion = ntohl(response_header->out_version); + code = cc_int_context_new(outContext, ntohl(response_header->out_ctx), ntohl(response_header->out_version)); if (!vendor[0]) { char * string; - code = cci_msg_retrieve_blob(response, response_header->vendor_offset, response_header->vendor_length, &string); + code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string); strncpy(vendor, string, sizeof(vendor)-1); vendor[sizeof(vendor)-1] = '\0'; free(string); diff --git a/src/lib/ccapi/client/cacheapi.def b/src/lib/ccapi/client/cacheapi.def new file mode 100644 index 000000000..c54cc1106 --- /dev/null +++ b/src/lib/ccapi/client/cacheapi.def @@ -0,0 +1,29 @@ +EXPORTS + ; ccapi v3 only exports one function + cc_initialize @14 + + ; ccapi v2 compatibility functions + cc_close @2 + cc_create @3 + cc_destroy @4 + cc_free_NC_info @5 + cc_free_creds @6 + cc_free_name @7 + cc_free_principal @8 + cc_get_NC_info @9 + cc_get_change_time @10 + cc_get_cred_version @11 + cc_get_name @12 + cc_get_principal @13 + cc_lock_request @15 + cc_open @16 + cc_remove_cred @17 + cc_seq_fetch_NCs_begin @18 + cc_seq_fetch_NCs_end @19 + cc_seq_fetch_NCs_next @20 + cc_seq_fetch_creds_begin @21 + cc_seq_fetch_creds_end @22 + cc_seq_fetch_creds_next @23 + cc_set_principal @24 + cc_shutdown @25 + cc_store @26 diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c index 5de3880e4..42064d54d 100644 --- a/src/lib/ccapi/client/ccache.c +++ b/src/lib/ccapi/client/ccache.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -49,9 +49,16 @@ #include #include "credentials.h" #include "ccache.h" +#include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" +/* + * cc_int_ccache_new + * + * Input parameters in host order. + */ + cc_int32 cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache ) { @@ -97,11 +104,12 @@ cc_int_ccache_new( cc_ccache_t * pccache, cc_handle hctx, cc_handle hccache ) cc_int32 cc_int_ccache_release( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_release_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_release_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -114,8 +122,8 @@ cc_int_ccache_release( cc_ccache_t ccache ) request_header = (ccmsg_ccache_release_t*)malloc(sizeof(ccmsg_ccache_release_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_RELEASE, &request); if (code != ccNoError) { @@ -127,10 +135,11 @@ cc_int_ccache_release( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -146,11 +155,12 @@ cc_int_ccache_release( cc_ccache_t ccache ) cc_int32 cc_int_ccache_destroy( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_destroy_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_destroy_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -163,8 +173,8 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) request_header = (ccmsg_ccache_destroy_t*)malloc(sizeof(ccmsg_ccache_destroy_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_DESTROY, &request); if (code != ccNoError) { @@ -176,10 +186,11 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -194,11 +205,12 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) cc_int32 cc_int_ccache_set_default( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_set_default_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_set_default_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -211,8 +223,8 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) request_header = (ccmsg_ccache_set_default_t*)malloc(sizeof(ccmsg_ccache_set_default_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_SET_DEFAULT, &request); if (code != ccNoError) { @@ -224,10 +236,11 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -241,11 +254,12 @@ cc_int32 cc_int_ccache_get_credentials_version( cc_ccache_t ccache, cc_uint32* credentials_version) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_creds_version_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -258,8 +272,8 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_creds_version_t*)malloc(sizeof(ccmsg_ccache_get_creds_version_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CREDS_VERSION, &request); if (code != ccNoError) { @@ -271,12 +285,13 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_creds_version_resp_t * response_header = (ccmsg_ccache_get_creds_version_resp_t*)response->header; - *credentials_version = response_header->version; + *credentials_version = ntohl(response_header->version); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -287,14 +302,14 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, } cc_int32 -cc_int_ccache_get_name( cc_ccache_t ccache, - cc_string_t* name ) +cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_name_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -307,8 +322,8 @@ cc_int_ccache_get_name( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_name_t*)malloc(sizeof(ccmsg_ccache_get_name_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_NAME, &request); if (code != ccNoError) { @@ -320,10 +335,11 @@ cc_int_ccache_get_name( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * string; ccmsg_ccache_get_name_resp_t * response_header = (ccmsg_ccache_get_name_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->name_offset, @@ -345,11 +361,12 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, cc_uint32 credentials_version, cc_string_t* principal ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_principal_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -362,9 +379,9 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_principal_t*)malloc(sizeof(ccmsg_ccache_get_principal_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); if (code != ccNoError) { @@ -376,10 +393,11 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { char * string; ccmsg_ccache_get_principal_resp_t * response_header = (ccmsg_ccache_get_principal_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->principal_offset, @@ -401,12 +419,13 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, cc_uint32 credentials_version, const char* principal ) { - cc_uint32 blob_pos; - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_uint32 blob_pos; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_set_principal_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -419,9 +438,9 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, request_header = (ccmsg_ccache_set_principal_t*)malloc(sizeof(ccmsg_ccache_set_principal_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); if (code != ccNoError) { @@ -436,17 +455,18 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, return code; } - request_header->principal_offset = blob_pos; - request_header->principal_len = strlen(principal) + 1; + request_header->principal_offset = htonl(blob_pos); + request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_principal_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -460,11 +480,12 @@ cc_int32 cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, cc_credentials_iterator_t* iterator ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_creds_iterator_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -477,10 +498,10 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, request_header = (ccmsg_ccache_creds_iterator_t*)malloc(sizeof(ccmsg_ccache_creds_iterator_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); - code = cci_msg_new(ccmsg_CCACHE_CREDS_ITERATOR, &request); + code = cci_msg_new(ccmsg_CCACHE_NEW_CREDS_ITERATOR, &request); if (code != ccNoError) { free(request_header); return code; @@ -490,12 +511,14 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_creds_iterator_resp_t * response_header = (ccmsg_ccache_creds_iterator_resp_t*)response->header; - code = cc_int_credentials_iterator_new(iterator, response_header->iterator); + code = cc_int_credentials_iterator_new(iterator, int_ccache->ctx, int_ccache->handle, + ntohll(response_header->iterator)); } else { code = ccErrBadInternalMessage; } @@ -508,14 +531,15 @@ cc_int32 cc_int_ccache_store_credentials( cc_ccache_t ccache, const cc_credentials_union* credentials ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_store_creds_t *request_header; - cc_msg_t *response; - char *flat_cred = 0; - cc_uint32 flat_cred_len = 0; - cc_uint32 blob_pos; - cc_int32 code; + cc_msg_t *response; + char *flat_cred = 0; + cc_uint32 flat_cred_len = 0; + cc_uint32 blob_pos; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || credentials == NULL ) return ccErrBadParam; @@ -528,8 +552,8 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, request_header = (ccmsg_ccache_store_creds_t*)malloc(sizeof(ccmsg_ccache_store_creds_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_STORE_CREDS, &request); if (code != ccNoError) { @@ -562,18 +586,19 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, return code; } - request_header->creds_version = credentials->version; - request_header->creds_offset = blob_pos; - request_header->creds_len = flat_cred_len; + request_header->creds_version = htonl(credentials->version); + request_header->creds_offset = htonl(blob_pos); + request_header->creds_len = htonl(flat_cred_len); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_store_creds_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -588,12 +613,13 @@ cc_int32 cc_int_ccache_remove_credentials( cc_ccache_t ccache, cc_credentials_t credentials ) { - cc_int_ccache_t int_ccache; - cc_int_credentials_t int_creds; - cc_msg_t *request; - ccmsg_ccache_rem_creds_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_int_credentials_t int_creds; + cc_msg_t *request; + ccmsg_ccache_rem_creds_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || credentials == NULL ) return ccErrBadParam; @@ -611,9 +637,9 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds = int_creds->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds = htonll(int_creds->handle); code = cci_msg_new(ccmsg_CCACHE_REM_CREDS, &request); if (code != ccNoError) { @@ -625,10 +651,11 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -643,12 +670,13 @@ cc_int32 cc_int_ccache_move( cc_ccache_t source, cc_ccache_t destination ) { - cc_int_ccache_t int_ccache_source; - cc_int_ccache_t int_ccache_dest; - cc_msg_t *request; + cc_int_ccache_t int_ccache_source; + cc_int_ccache_t int_ccache_dest; + cc_msg_t *request; ccmsg_ccache_move_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( source == NULL || destination == NULL ) return ccErrBadParam; @@ -673,18 +701,19 @@ cc_int_ccache_move( cc_ccache_t source, return code; } - request_header->ctx = int_ccache_source->ctx; - request_header->ccache_source = int_ccache_source->handle; - request_header->ccache_dest = int_ccache_dest->handle; + request_header->ctx = htonll(int_ccache_source->ctx); + request_header->ccache_source = htonll(int_ccache_source->handle); + request_header->ccache_dest = htonll(int_ccache_dest->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_move_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -698,14 +727,16 @@ cc_int_ccache_lock( cc_ccache_t ccache, cc_uint32 lock_type, cc_uint32 block ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_lock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL || - (lock_type != cc_lock_read && lock_type != cc_lock_write) || + (lock_type != cc_lock_read && lock_type != cc_lock_write && + lock_type != cc_lock_upgrade && lock_type != cc_lock_downgrade) || (block != cc_lock_block && block != cc_lock_noblock) ) return ccErrBadParam; @@ -724,17 +755,18 @@ cc_int_ccache_lock( cc_ccache_t ccache, return code; } - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->lock_type; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->lock_type = htonl(lock_type); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_lock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); // TODO: if (block == cc_lock_block) ..... } else if (response->type == ccmsg_ACK) { @@ -750,11 +782,12 @@ cc_int_ccache_lock( cc_ccache_t ccache, cc_int32 cc_int_ccache_unlock( cc_ccache_t ccache ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_unlock_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_msg_t *request; + ccmsg_ccache_unlock_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -774,17 +807,18 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) return code; } - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_unlock_t)); code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = htonl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = htonl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -797,13 +831,15 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) cc_int32 cc_int_ccache_get_last_default_time( cc_ccache_t ccache, - cc_time_t* time_offset ) + cc_time* time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_last_default_time_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_time64 t64; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -816,8 +852,8 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_last_default_time_t*)malloc(sizeof(ccmsg_ccache_get_last_default_time_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_LAST_DEFAULT_TIME, &request); if (code != ccNoError) { @@ -829,13 +865,16 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_last_default_time_resp_t * response_header = (ccmsg_ccache_get_last_default_time_resp_t*)response->header; - *time_offset = response_header->last_default_time; - code = ccNoError; + t64 = ntohll(response_header->last_default_time); + /* TODO: validate that we do not overflow the max value of time_offset */ + *time_offset = t64; + code = ccNoError; } else { code = ccErrBadInternalMessage; } @@ -845,14 +884,15 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, } cc_int32 -cc_int_ccache_get_change_time( cc_ccache_t ccache, - cc_time_t* time ) +cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_change_time_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_time64 t64; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -865,8 +905,8 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_change_time_t*)malloc(sizeof(ccmsg_ccache_get_change_time_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CHANGE_TIME, &request); if (code != ccNoError) { @@ -878,12 +918,15 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_get_change_time_resp_t * response_header = (ccmsg_ccache_get_change_time_resp_t*)response->header; - *time = response_header->time; + t64 = htonll(response_header->time); + /* TODO: validate that we do not overflow 'time' */ + *time = t64; code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -898,12 +941,13 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_ccache_t compare_to, cc_uint32* equal ) { - cc_int_ccache_t int_ccache; - cc_int_ccache_t int_compare_to; - cc_msg_t *request; - ccmsg_ccache_compare_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_int_ccache_t int_ccache; + cc_int_ccache_t int_compare_to; + cc_msg_t *request; + ccmsg_ccache_compare_t *request_header; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -918,9 +962,9 @@ cc_int_ccache_compare( cc_ccache_t ccache, request_header = (ccmsg_ccache_compare_t*)malloc(sizeof(ccmsg_ccache_compare_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache1 = int_ccache->handle; - request_header->ccache2 = int_compare_to->handle; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache1 = htonll(int_ccache->handle); + request_header->ccache2 = htonll(int_compare_to->handle); code = cci_msg_new(ccmsg_CCACHE_COMPARE, &request); if (code != ccNoError) { @@ -932,12 +976,13 @@ cc_int_ccache_compare( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { ccmsg_ccache_compare_resp_t * response_header = (ccmsg_ccache_compare_resp_t*)response->header; - *equal = response_header->is_equal; + *equal = ntohl(response_header->is_equal); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -950,13 +995,14 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_int32 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t* time_offset ) + cc_time* time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_get_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -969,9 +1015,9 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_get_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_get_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -983,12 +1029,13 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; + code = ntohl(nack_header->err_code); } else if (response->type == ccmsg_ACK) { ccmsg_ccache_get_kdc_time_offset_resp_t * response_header = (ccmsg_ccache_get_kdc_time_offset_resp_t*)response->header; - *time_offset = response_header->offset; + *time_offset = ntohll(response_header->offset); code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1001,13 +1048,15 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t time_offset ) + cc_time time_offset ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_set_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_int64 t64; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -1020,9 +1069,11 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_set_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_set_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); + t64 = time_offset; + request_header->offset = htonll(t64); code = cci_msg_new(ccmsg_CCACHE_SET_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -1034,10 +1085,11 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1051,11 +1103,12 @@ cc_int32 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version ) { - cc_int_ccache_t int_ccache; - cc_msg_t *request; + cc_int_ccache_t int_ccache; + cc_msg_t *request; ccmsg_ccache_clear_kdc_time_offset_t *request_header; - cc_msg_t *response; - cc_int32 code; + cc_msg_t *response; + cc_uint32 type; + cc_int32 code; if ( ccache == NULL ) return ccErrBadParam; @@ -1068,9 +1121,9 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, request_header = (ccmsg_ccache_clear_kdc_time_offset_t*)malloc(sizeof(ccmsg_ccache_clear_kdc_time_offset_t)); if (request_header == NULL) return ccErrNoMem; - request_header->ctx = int_ccache->ctx; - request_header->ccache = int_ccache->handle; - request_header->creds_version = credentials_version; + request_header->ctx = htonll(int_ccache->ctx); + request_header->ccache = htonll(int_ccache->handle); + request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_CLEAR_KDC_TIME_OFFSET, &request); if (code != ccNoError) { @@ -1082,10 +1135,11 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, code = cci_perform_rpc(request, &response); - if (response->type == ccmsg_NACK) { + type = ntohl(response->type); + if (type == ccmsg_NACK) { ccmsg_nack_t * nack_header = (ccmsg_nack_t *)response->header; - code = nack_header->err_code; - } else if (response->type == ccmsg_ACK) { + code = ntohl(nack_header->err_code); + } else if (type == ccmsg_ACK) { code = ccNoError; } else { code = ccErrBadInternalMessage; @@ -1094,5 +1148,3 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, cci_msg_destroy(response); return code; } - - diff --git a/src/lib/ccapi/client/ccache.h b/src/lib/ccapi/client/ccache.h index e3b3993ee..0a92ebf63 100644 --- a/src/lib/ccapi/client/ccache.h +++ b/src/lib/ccapi/client/ccache.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -114,11 +114,11 @@ cc_int_ccache_unlock( cc_ccache_t ccache ); cc_int32 cc_int_ccache_get_last_default_time( cc_ccache_t ccache, - cc_time_t* time ); + cc_time* time ); cc_int32 cc_int_ccache_get_change_time( cc_ccache_t ccache, - cc_time_t* time ); + cc_time* time ); cc_int32 cc_int_ccache_compare( cc_ccache_t ccache, @@ -128,12 +128,12 @@ cc_int_ccache_compare( cc_ccache_t ccache, cc_int32 cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t* time_offset ); + cc_time* time_offset ); cc_int32 cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version, - cc_time_t time_offset ); + cc_time time_offset ); cc_int32 cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, diff --git a/src/lib/ccapi/client/ccache_iterator.c b/src/lib/ccapi/client/ccache_iterator.c index 03266b1bb..3f3e1675e 100644 --- a/src/lib/ccapi/client/ccache_iterator.c +++ b/src/lib/ccapi/client/ccache_iterator.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,6 +47,7 @@ #include #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 c55d72ee6..5a390b82e 100644 --- a/src/lib/ccapi/client/ccache_iterator.h +++ b/src/lib/ccapi/client/ccache_iterator.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -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 000000000..ffbb589a2 --- /dev/null +++ b/src/lib/ccapi/client/ccapiv2.c @@ -0,0 +1,286 @@ +/* $Copyright: + * + * Copyright 1998-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ +/* + * This is backwards compatibility for CCache API v2 clients to be able to run + * against the CCache API v3 library + */ + +#include "CredentialsCache2.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +CCACHE_API cc_int32 cc_shutdown ( + apiCB** ioContext) +{ + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_NC_info ( + apiCB* inContext, + infoNC*** outInfo) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_change_time ( + apiCB* inContext, + cc_time_t* outTime) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_open ( + apiCB* inContext, + const char* inName, + cc_int32 inVersion, + cc_uint32 inFlags, + ccache_p** outCCache) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_create ( + apiCB* inContext, + const char* inName, + const char* inPrincipal, + cc_int32 inVersion, + cc_uint32 inFlags, + ccache_p** outCCache) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_close ( + apiCB* inContext, + ccache_p** ioCCache) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_destroy ( + apiCB* inContext, + ccache_p** ioCCache) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_begin ( + apiCB* inContext, + ccache_cit** outIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_next ( + apiCB* inContext, + ccache_p** outCCache, + ccache_cit* inIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_NCs_end ( + apiCB* inContext, + ccache_cit** ioIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_name ( + apiCB* inContext, + ccache_p* inCCache, + char** outName) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_cred_version ( + apiCB* inContext, + ccache_p* inCCache, + cc_int32* outVersion) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_set_principal ( + apiCB* inContext, + ccache_p* inCCache, + cc_int32 inVersion, + char* inPrincipal) +{ + if (inVersion != CC_CRED_V4 && inVersion != CC_CRED_V5) + return CC_ERR_CRED_VERSION; + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_get_principal ( + apiCB* inContext, + ccache_p* inCCache, + char** outPrincipal) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_store ( + apiCB* inContext, + ccache_p* inCCache, + cred_union inCredentials) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_remove_cred ( + apiCB* inContext, + ccache_p* inCCache, + cred_union inCredentials) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_begin ( + apiCB* inContext, + const ccache_p* inCCache, + ccache_cit** outIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_next ( + apiCB* inContext, + cred_union** outCreds, + ccache_cit* inIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_seq_fetch_creds_end ( + apiCB* inContext, + ccache_cit** ioIterator) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_principal ( + apiCB* inContext, + char** ioPrincipal) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_name ( + apiCB* inContext, + char** ioName) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_creds ( + apiCB* inContext, + cred_union** creds) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + +CCACHE_API cc_int32 cc_free_NC_info ( + apiCB* inContext, + infoNC*** ioInfo) +{ + + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c index 86c41b8e7..efac3020c 100644 --- a/src/lib/ccapi/client/context.c +++ b/src/lib/ccapi/client/context.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,9 +47,15 @@ #include #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 cd5ca678d..6ff113a26 100644 --- a/src/lib/ccapi/client/context.h +++ b/src/lib/ccapi/client/context.h @@ -66,7 +66,7 @@ cc_int_context_release( cc_context_t context ); cc_int32 cc_int_context_get_change_time( cc_context_t context, - cc_time_t* time); + cc_time* time); cc_int32 cc_int_context_get_default_ccache_name( cc_context_t context, diff --git a/src/lib/ccapi/client/credentials.c b/src/lib/ccapi/client/credentials.c index b0a3df2b7..8b8867689 100644 --- a/src/lib/ccapi/client/credentials.c +++ b/src/lib/ccapi/client/credentials.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -159,23 +159,23 @@ cc_int_credentials_release( cc_credentials_t creds ) cc_int32 cc_int_credentials_compare( cc_credentials_t credentials, - cc_credentials_t compare_to, - cc_uint32* equal ) + cc_credentials_t compare_to, + cc_uint32* equal ) { cc_int_credentials_t int_credentials; cc_int_credentials_t int_compare_to; if ( credentials == NULL || compare_to == NULL || equal == NULL ) return ccErrBadParam; - + int_credentials = (cc_int_credentials_t)credentials; + int_compare_to = (cc_int_credentials_t)compare_to; + if ( int_credentials->magic != CC_CREDS_MAGIC || int_compare_to->magic != CC_CREDS_MAGIC ) return ccErrInvalidCredentials; - int_credentials = (cc_int_credentials_t)credentials; - int_compare_to = (cc_int_credentials_t)compare_to; - *equal = (int_credentials->handle == int_compare_to->handle); + return ccNoError; } diff --git a/src/lib/ccapi/client/credentials.h b/src/lib/ccapi/client/credentials.h index 320c61825..dfd589f32 100644 --- a/src/lib/ccapi/client/credentials.h +++ b/src/lib/ccapi/client/credentials.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -84,8 +84,8 @@ cci_creds_v5_marshall( cc_credentials_v5_t * creds, cc_int32 cci_creds_v4_unmarshall( char * flat, - cc_uint32 len, - cc_credentials_union * creds); + cc_uint32 len, + cc_credentials_union * creds); cc_int32 cci_creds_v5_unmarshall( char * flat, diff --git a/src/lib/ccapi/client/credentials_iterator.c b/src/lib/ccapi/client/credentials_iterator.c index b7333daf3..bae60ffdf 100644 --- a/src/lib/ccapi/client/credentials_iterator.c +++ b/src/lib/ccapi/client/credentials_iterator.c @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -47,6 +47,7 @@ #include #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 2a6f8edf2..954d2f1af 100644 --- a/src/lib/ccapi/client/credentials_iterator.h +++ b/src/lib/ccapi/client/credentials_iterator.h @@ -1,6 +1,6 @@ /* $Copyright: * - * Copyright 2004 by the Massachusetts Institute of Technology. + * Copyright 2004-2006 by the Massachusetts Institute of Technology. * * All rights reserved. * @@ -69,4 +69,8 @@ cc_int32 cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, cc_credentials_t * credentials ); +cc_int32 +cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter, + cc_credentials_iterator_t * new_iter ); + diff --git a/src/lib/ccapi/client/marshall.c b/src/lib/ccapi/client/marshall.c new file mode 100644 index 000000000..31ebacd7b --- /dev/null +++ b/src/lib/ccapi/client/marshall.c @@ -0,0 +1,445 @@ +/* $Copyright: + * + * Copyright 2004-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ + +/* marshall.c */ + +#include +#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 000000000..facaffffc --- /dev/null +++ b/src/lib/ccapi/client/msg.c @@ -0,0 +1,628 @@ +/* $Copyright: + * + * Copyright 2004-2006 by the Massachusetts Institute of Technology. + * + * All rights reserved. + * + * Export of this software from the United States of America may require a + * specific license from the United States Government. It is the + * responsibility of any person or organization contemplating export to + * obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute + * this software and its documentation for any purpose and without fee is + * hereby granted, provided that the above copyright notice appear in all + * copies and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of M.I.T. not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. Furthermore if you + * modify this software you must label your software as modified software + * and not distribute it in such a fashion that it might be confused with + * the original MIT software. M.I.T. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Individual source code files are copyright MIT, Cygnus Support, + * OpenVision, Oracle, Sun Soft, FundsXpress, and others. + * + * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira, + * and Zephyr are trademarks of the Massachusetts Institute of Technology + * (MIT). No commercial use of these trademarks may be made without prior + * written permission of MIT. + * + * "Commercial use" means use of a name in a product or other for-profit + * manner. It does NOT prevent a commercial firm from referring to the MIT + * trademarks in order to convey information (although in doing so, + * recognition of their trademark status should be given). + * $ + */ + +/* + * Verifiable, extensible message format. + * + * Format: + * + * + * + * + * + * + * + * + * + * ... + * + * + * 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 From 46feb62dc0a36171dd14d33a9aab8b9af42fc595 Mon Sep 17 00:00:00 2001 From: Jeffrey Altman Date: Mon, 22 May 2006 17:17:07 +0000 Subject: Move msg.c and marshall.c to common library Add dllmain.c which contains the Windows DllMain() entry point. This must be moved later to a Windows specific directory. Cleanup type usage and function name references. All that is missing now from the client DLL is a definition of cci_perform_rpc() which is the entry point to the IPC routine. git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18028 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/ccapi/client/NTMakefile | 21 +- src/lib/ccapi/client/cacheapi.c | 2 +- src/lib/ccapi/client/ccache.c | 8 +- src/lib/ccapi/client/ccache_iterator.c | 1 + src/lib/ccapi/client/ccapiv2.c | 11 +- src/lib/ccapi/client/ccstring.c | 12 +- src/lib/ccapi/client/ccstring.h | 10 +- src/lib/ccapi/client/context.c | 27 +- src/lib/ccapi/client/credentials.c | 4 +- src/lib/ccapi/client/credentials_iterator.c | 1 + src/lib/ccapi/client/dllmain.c | 15 + src/lib/ccapi/client/marshall.c | 445 -------------------- src/lib/ccapi/client/msg.c | 628 ---------------------------- 13 files changed, 72 insertions(+), 1113 deletions(-) create mode 100644 src/lib/ccapi/client/dllmain.c delete mode 100644 src/lib/ccapi/client/marshall.c delete 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 57ff87416..f9d85b463 100644 --- a/src/lib/ccapi/client/NTMakefile +++ b/src/lib/ccapi/client/NTMakefile @@ -1,22 +1,25 @@ !INCLUDE -CFLAGS = -I../include +CFLAGS = -I../include $(cdebug) $(cflags) $(cvarsdll) -CCAPI_OBJS = cacheapi.obj context.obj ccache.obj credentials.obj ccache_iterator.obj \ - credentials_iterator.obj ccstring.obj marshall.obj msg.obj +CC_CLIENT_OBJS = cacheapi.obj context.obj ccache.obj credentials.obj ccache_iterator.obj \ + credentials_iterator.obj ccstring.obj ccapiv2.obj -CCAPI_LIB = ccapi.lib +CC_CLIENT_LIB = cc_client.lib -$(CCAPI_LIB): $(CCAPI_OBJS) +CC_COMMON_LIB = ..\common\cc_common.lib + +$(CC_CLIENT_LIB): $(CC_CLIENT_OBJS) $(implib) /NOLOGO /OUT:$@ $** CCAPI_DLLFILE = krbcc32.dll -$(CCAPI_DLLFILE): $(CCAPI_LIB) - $(DLLGUILINK) -def:windows\krbcc32.def - $(DLLPREP) +WINLIBS = ws2_32.lib $(guilibsdll) msvcrt.lib + +$(CCAPI_DLLFILE): dllmain.obj $(CC_CLIENT_LIB) $(CC_COMMON_LIB) + $(link) /OUT:$@ $(ldebug) $(dlllflags) /NODEFAULTLIB:libcmt.lib -def:cacheapi.def $** $(WINLIBS) all: $(CCAPI_DLLFILE) clean: - del *.obj *.lib + del *.obj *.lib *.dll *.exp diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c index 704925dfd..14a1eb476 100644 --- a/src/lib/ccapi/client/cacheapi.c +++ b/src/lib/ccapi/client/cacheapi.c @@ -116,7 +116,7 @@ cc_initialize ( cc_context_t* outContext, } else if (type == ccmsg_ACK) { response_header = (ccmsg_init_resp_t *)response->header; *outSupportedVersion = ntohl(response_header->out_version); - code = cc_int_context_new(outContext, ntohl(response_header->out_ctx), ntohl(response_header->out_version)); + code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version)); if (!vendor[0]) { char * string; diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c index 42064d54d..790ff6f67 100644 --- a/src/lib/ccapi/client/ccache.c +++ b/src/lib/ccapi/client/ccache.c @@ -48,10 +48,12 @@ #include #include #include "credentials.h" +#include "credentials_iterator.h" #include "ccache.h" #include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" +#include "ccstring.h" /* * cc_int_ccache_new @@ -345,7 +347,7 @@ cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) code = cci_msg_retrieve_blob(response, response_header->name_offset, response_header->name_len, &string); if (code == ccNoError) { - code = cc_string_new(&name, string); + code = cci_string_new(name, string); free(string); } } else { @@ -403,7 +405,7 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, code = cci_msg_retrieve_blob(response, response_header->principal_offset, response_header->principal_len, &string); if (code == ccNoError) { - code = cc_string_new(&principal, string); + code = cci_string_new(principal, string); free(string); } } else { @@ -1035,7 +1037,7 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, 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 = ntohll(response_header->offset); + *time_offset = (cc_time64)ntohll(response_header->offset); code = ccNoError; } else { code = ccErrBadInternalMessage; diff --git a/src/lib/ccapi/client/ccache_iterator.c b/src/lib/ccapi/client/ccache_iterator.c index 3f3e1675e..b0ccbe610 100644 --- a/src/lib/ccapi/client/ccache_iterator.c +++ b/src/lib/ccapi/client/ccache_iterator.c @@ -46,6 +46,7 @@ #include #include #include +#include "ccache.h" #include "ccache_iterator.h" #include "cc_rpc.h" #include "msg.h" diff --git a/src/lib/ccapi/client/ccapiv2.c b/src/lib/ccapi/client/ccapiv2.c index ffbb589a2..82b04c2c8 100644 --- a/src/lib/ccapi/client/ccapiv2.c +++ b/src/lib/ccapi/client/ccapiv2.c @@ -69,7 +69,7 @@ CCACHE_API cc_int32 cc_get_NC_info ( CCACHE_API cc_int32 cc_get_change_time ( apiCB* inContext, - cc_time_t* outTime) + cc_time* outTime) { /* replace this return value when the function is implemented */ @@ -279,6 +279,15 @@ CCACHE_API cc_int32 cc_free_NC_info ( return CC_NOT_SUPP; } +CCACHE_API cc_int32 cc_lock_request( + apiCB* inContext, + const ccache_p* inCCache, + const cc_int32 lock_type) +{ + /* replace this return value when the function is implemented */ + return CC_NOT_SUPP; +} + #ifdef __cplusplus } diff --git a/src/lib/ccapi/client/ccstring.c b/src/lib/ccapi/client/ccstring.c index 419bfef77..6f3fa2bcb 100644 --- a/src/lib/ccapi/client/ccstring.c +++ b/src/lib/ccapi/client/ccstring.c @@ -50,9 +50,9 @@ #include "ccstring.h" cc_int32 -cc_int_string_new( cc_string_t * pstring, char * data ) +cci_string_new( cc_string_t * pstring, char * data ) { - cc_int_string_t string = (cc_int_string_t)malloc(sizeof(cc_int_string_d)); + cci_string_t string = (cci_string_t)malloc(sizeof(cci_string_d)); if ( string == NULL ) return ccErrNoMem; @@ -63,7 +63,7 @@ cc_int_string_new( cc_string_t * pstring, char * data ) } string->magic = CC_STRING_MAGIC; - string->functions->release = cc_int_string_release; + string->functions->release = cci_string_release; string->data = strdup(data); if ( string->data == NULL ) { @@ -77,13 +77,13 @@ cc_int_string_new( cc_string_t * pstring, char * data ) } cc_int32 -cc_int_string_release( cc_string_t str ) +cci_string_release( cc_string_t str ) { - cc_int_string_t int_string; + cci_string_t int_string; if ( str == NULL ) return ccErrBadParam; - int_string = (cc_int_string_t)str; + int_string = (cci_string_t)str; if ( int_string->magic != CC_STRING_MAGIC ) return ccErrInvalidString; diff --git a/src/lib/ccapi/client/ccstring.h b/src/lib/ccapi/client/ccstring.h index 9e0ad223f..2c973afbb 100644 --- a/src/lib/ccapi/client/ccstring.h +++ b/src/lib/ccapi/client/ccstring.h @@ -45,7 +45,7 @@ #define CC_STRING_MAGIC ('S'<<24 | 'T'<<16 | 'R'<<8 | 'I') -struct cc_int_string_d { +struct cci_string_d { char* data; cc_string_f* functions; #if TARGET_OS_MAC @@ -53,13 +53,13 @@ struct cc_int_string_d { #endif cc_uint32 magic; }; -typedef struct cc_int_string_d cc_int_string_d; -typedef cc_int_string_d* cc_int_string_t; +typedef struct cci_string_d cci_string_d; +typedef cci_string_d* cci_string_t; cc_int32 -cc_int_string_new( cc_string_t * pstring, char * data ); +cci_string_new( cc_string_t * pstring, char * data ); cc_int32 -cc_int_string_release( cc_string_t string ); +cci_string_release( cc_string_t string ); diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c index efac3020c..8515f695b 100644 --- a/src/lib/ccapi/client/context.c +++ b/src/lib/ccapi/client/context.c @@ -47,9 +47,12 @@ #include #include #include "context.h" +#include "ccache.h" +#include "ccache_iterator.h" #include "cc_rpc.h" #include "msg.h" #include "msg_headers.h" +#include "ccstring.h" /* cc_int_context_new * @@ -98,7 +101,6 @@ cc_int_context_release( cc_context_t context ) ccmsg_ctx_release_t *request_header; cc_msg_t *response; cc_uint32 type; - cc_time64 t64; cc_int32 code; if ( context == NULL ) @@ -112,7 +114,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 = htonl(int_context->handle); + request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_RELEASE, &request); if (code != ccNoError) { @@ -239,7 +241,7 @@ cc_int_context_get_default_ccache_name( cc_context_t context, code = cci_msg_retrieve_blob(response, response_header->name_offset, response_header->name_len, &string); if (code == ccNoError) { - code = cc_string_new(&name, string); + code = cci_string_new(name, string); free(string); } } else { @@ -277,8 +279,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 = htonl(int_context->handle); - request_header->ctx2 = htonl(int_compare_to->handle); + request_header->ctx1 = htonll(int_context->handle); + request_header->ctx2 = htonll(int_compare_to->handle); code = cci_msg_new(ccmsg_CTX_COMPARE, &request); if (code != ccNoError) { @@ -411,7 +413,7 @@ cc_int_context_open_ccache( cc_context_t context, code = ntohl(nack_header->err_code); } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_open_resp_t*)response->header; - code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); + code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -462,7 +464,7 @@ cc_int_context_open_default_ccache( cc_context_t context, code = ntohl(nack_header->err_code); } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_open_resp_t*)response->header; - code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); + code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -538,7 +540,7 @@ cc_int_context_create_ccache( cc_context_t context, code = ntohl(nack_header->err_code); } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response->header; - code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); + code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -604,7 +606,7 @@ cc_int_context_create_default_ccache( cc_context_t context, code = ntohl(nack_header->err_code); } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response->header; - code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); + code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -670,7 +672,7 @@ cc_int_context_create_new_ccache( cc_context_t context, code = ntohl(nack_header->err_code); } else if (type == ccmsg_ACK) { response_header = (ccmsg_ccache_create_resp_t*)response-> header; - code = cc_int_cache_new(ccache, int_context->handle, ntohll(response_header->ccache)); + code = cc_int_ccache_new(ccache, int_context->handle, ntohll(response_header->ccache)); } else { code = ccErrBadInternalMessage; } @@ -790,7 +792,7 @@ cc_int_context_clone( cc_context_t inContext, cc_int32* supportedVersion, char const** vendor ) { - cc_int_context_t int_context, new_context; + cc_int_context_t int_context; static char vendor_st[128] = ""; cc_msg_t *request; ccmsg_ctx_clone_t *request_header; @@ -845,7 +847,7 @@ cc_int_context_clone( cc_context_t inContext, } 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)); + code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version)); if (!vendor_st[0]) { char * string; @@ -870,7 +872,6 @@ cc_int_context_get_version( cc_context_t context, cc_int32* version ) { cc_int_context_t int_context; - cc_int32 code; if ( context == NULL || version == NULL ) diff --git a/src/lib/ccapi/client/credentials.c b/src/lib/ccapi/client/credentials.c index 8b8867689..dbdf6345e 100644 --- a/src/lib/ccapi/client/credentials.c +++ b/src/lib/ccapi/client/credentials.c @@ -88,10 +88,10 @@ cc_int_credentials_new( cc_credentials_t *pcredentials, cc_uint32 version, switch ( version ) { case cc_credentials_v4: - code = cci_cred_v4_unmarshall(data, len, credentials->data); + code = cci_creds_v4_unmarshall(data, len, credentials->data); break; case cc_credentials_v5: - code = cci_cred_v5_unmarshall(data, len, credentials->data); + code = cci_creds_v5_unmarshall(data, len, credentials->data); break; default: free(credentials); diff --git a/src/lib/ccapi/client/credentials_iterator.c b/src/lib/ccapi/client/credentials_iterator.c index bae60ffdf..f61d0ade8 100644 --- a/src/lib/ccapi/client/credentials_iterator.c +++ b/src/lib/ccapi/client/credentials_iterator.c @@ -46,6 +46,7 @@ #include #include #include +#include "credentials.h" #include "credentials_iterator.h" #include "cc_rpc.h" #include "msg.h" diff --git a/src/lib/ccapi/client/dllmain.c b/src/lib/ccapi/client/dllmain.c new file mode 100644 index 000000000..6b4d6bfdd --- /dev/null +++ b/src/lib/ccapi/client/dllmain.c @@ -0,0 +1,15 @@ +#include + +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, + LPVOID lpvReserved) +{ + switch (fdwReason) { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + default: + return TRUE; + } +} + diff --git a/src/lib/ccapi/client/marshall.c b/src/lib/ccapi/client/marshall.c deleted file mode 100644 index 31ebacd7b..000000000 --- a/src/lib/ccapi/client/marshall.c +++ /dev/null @@ -1,445 +0,0 @@ -/* $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 deleted file mode 100644 index facaffffc..000000000 --- a/src/lib/ccapi/client/msg.c +++ /dev/null @@ -1,628 +0,0 @@ -/* $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 From 3d6591dd63c23bcc0ae68e94a960c85fd53daad0 Mon Sep 17 00:00:00 2001 From: Jeffrey Altman Date: Mon, 5 Jun 2006 04:30:35 +0000 Subject: more updates git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18082 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/ccapi/client/NTMakefile | 13 +++---------- src/lib/ccapi/client/cacheapi.def | 29 ----------------------------- src/lib/ccapi/client/dllmain.c | 15 --------------- 3 files changed, 3 insertions(+), 54 deletions(-) delete mode 100644 src/lib/ccapi/client/cacheapi.def delete mode 100644 src/lib/ccapi/client/dllmain.c (limited to 'src/lib/ccapi/client') diff --git a/src/lib/ccapi/client/NTMakefile b/src/lib/ccapi/client/NTMakefile index f9d85b463..2ce87c350 100644 --- a/src/lib/ccapi/client/NTMakefile +++ b/src/lib/ccapi/client/NTMakefile @@ -1,6 +1,6 @@ !INCLUDE -CFLAGS = -I../include $(cdebug) $(cflags) $(cvarsdll) +CFLAGS = -I../include $(cdebug) $(cflags) $(cvarsmt) CC_CLIENT_OBJS = cacheapi.obj context.obj ccache.obj credentials.obj ccache_iterator.obj \ credentials_iterator.obj ccstring.obj ccapiv2.obj @@ -12,14 +12,7 @@ CC_COMMON_LIB = ..\common\cc_common.lib $(CC_CLIENT_LIB): $(CC_CLIENT_OBJS) $(implib) /NOLOGO /OUT:$@ $** -CCAPI_DLLFILE = krbcc32.dll - -WINLIBS = ws2_32.lib $(guilibsdll) msvcrt.lib - -$(CCAPI_DLLFILE): dllmain.obj $(CC_CLIENT_LIB) $(CC_COMMON_LIB) - $(link) /OUT:$@ $(ldebug) $(dlllflags) /NODEFAULTLIB:libcmt.lib -def:cacheapi.def $** $(WINLIBS) - -all: $(CCAPI_DLLFILE) +all: $(CC_CLIENT_LIB) clean: - del *.obj *.lib *.dll *.exp + del *.obj *.lib diff --git a/src/lib/ccapi/client/cacheapi.def b/src/lib/ccapi/client/cacheapi.def deleted file mode 100644 index c54cc1106..000000000 --- a/src/lib/ccapi/client/cacheapi.def +++ /dev/null @@ -1,29 +0,0 @@ -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/dllmain.c b/src/lib/ccapi/client/dllmain.c deleted file mode 100644 index 6b4d6bfdd..000000000 --- a/src/lib/ccapi/client/dllmain.c +++ /dev/null @@ -1,15 +0,0 @@ -#include - -BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, - LPVOID lpvReserved) -{ - switch (fdwReason) { - case DLL_PROCESS_ATTACH: - case DLL_THREAD_ATTACH: - case DLL_THREAD_DETACH: - case DLL_PROCESS_DETACH: - default: - return TRUE; - } -} - -- cgit From f42fa33b985c230736ad5d9080055916de33be8c Mon Sep 17 00:00:00 2001 From: Jeffrey Altman Date: Mon, 5 Jun 2006 17:49:34 +0000 Subject: improved error handling git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18083 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/ccapi/client/cacheapi.c | 26 +- src/lib/ccapi/client/ccache.c | 544 ++++++++++++++++++---------- src/lib/ccapi/client/ccache_iterator.c | 91 +++-- src/lib/ccapi/client/context.c | 402 ++++++++++++-------- src/lib/ccapi/client/credentials_iterator.c | 81 +++-- 5 files changed, 739 insertions(+), 405 deletions(-) (limited to 'src/lib/ccapi/client') diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c index 14a1eb476..c76ebe457 100644 --- a/src/lib/ccapi/client/cacheapi.c +++ b/src/lib/ccapi/client/cacheapi.c @@ -64,9 +64,9 @@ cc_initialize ( cc_context_t* outContext, char const** outVendor) { static char vendor[128] = ""; - cc_msg_t *request; + cc_msg_t *request = NULL; ccmsg_init_t *request_header; - cc_msg_t *response; + cc_msg_t *response = NULL; cc_uint32 type; ccmsg_init_resp_t *response_header; cc_int32 code; @@ -100,14 +100,17 @@ cc_initialize ( cc_context_t* outContext, request_header->in_version = htonl(inVersion); code = cci_msg_new(ccmsg_INIT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_init_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -131,8 +134,15 @@ cc_initialize ( cc_context_t* outContext, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c index 790ff6f67..e4b9673c7 100644 --- a/src/lib/ccapi/client/ccache.c +++ b/src/lib/ccapi/client/ccache.c @@ -107,9 +107,9 @@ 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_msg_t *request = NULL; + ccmsg_ccache_release_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -128,14 +128,17 @@ cc_int_ccache_release( cc_ccache_t ccache ) request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_RELEASE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_release_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -146,9 +149,16 @@ cc_int_ccache_release( cc_ccache_t ccache ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); - free(int_ccache->functions); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); + if (int_ccache->functions) + free(int_ccache->functions); free(int_ccache); return code; } @@ -158,9 +168,9 @@ 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_msg_t *request = NULL; + ccmsg_ccache_destroy_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -179,14 +189,17 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_DESTROY, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_destroy_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -197,8 +210,14 @@ cc_int_ccache_destroy( cc_ccache_t ccache ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); free(ccache); return code; } @@ -208,9 +227,9 @@ 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_msg_t *request = NULL; + ccmsg_ccache_set_default_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -229,14 +248,17 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_SET_DEFAULT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_default_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -247,8 +269,14 @@ cc_int_ccache_set_default( cc_ccache_t ccache ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -257,9 +285,9 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, cc_uint32* credentials_version) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_creds_version_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_creds_version_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -278,14 +306,17 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CREDS_VERSION, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_creds_version_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -298,8 +329,14 @@ cc_int_ccache_get_credentials_version( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -307,9 +344,9 @@ cc_int32 cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_name_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_name_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -328,14 +365,17 @@ cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_NAME, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_name_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -353,8 +393,14 @@ cc_int_ccache_get_name( cc_ccache_t ccache, cc_string_t* name ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -364,9 +410,9 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, cc_string_t* principal ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_principal_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_principal_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -386,14 +432,17 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_principal_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -411,8 +460,14 @@ cc_int_ccache_get_principal( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -423,9 +478,9 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, { 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_msg_t *request = NULL; + ccmsg_ccache_set_principal_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -445,24 +500,24 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, request_header->version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_PRINCIPAL, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_data_blob(request, (void*)principal, strlen(principal) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->principal_offset = htonl(blob_pos); request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_principal_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -473,8 +528,14 @@ cc_int_ccache_set_principal( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -483,9 +544,9 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, cc_credentials_iterator_t* iterator ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_creds_iterator_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_creds_iterator_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -504,14 +565,17 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_NEW_CREDS_ITERATOR, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_creds_iterator_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -524,8 +588,14 @@ cc_int_ccache_new_credentials_iterator( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -534,9 +604,9 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, const cc_credentials_union* credentials ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_store_creds_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_store_creds_t *request_header = NULL; + cc_msg_t *response = NULL; char *flat_cred = 0; cc_uint32 flat_cred_len = 0; cc_uint32 blob_pos; @@ -558,10 +628,8 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_STORE_CREDS, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; switch ( credentials->version ) { case cc_credentials_v4: @@ -571,30 +639,27 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, code = cci_creds_v5_marshall(credentials->credentials.credentials_v5, &flat_cred, &flat_cred_len); break; default: - cci_msg_destroy(request); - free(request_header); - return ccErrBadCredentialsVersion; - } - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; + code = ccErrBadCredentialsVersion; } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_data_blob(request, (void*)flat_cred, flat_cred_len, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->creds_version = htonl(credentials->version); request_header->creds_offset = htonl(blob_pos); request_header->creds_len = htonl(flat_cred_len); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_store_creds_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -605,9 +670,16 @@ cc_int_ccache_store_credentials( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - free(flat_cred); - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (flat_cred) + free(flat_cred); + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -617,9 +689,9 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, { 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_msg_t *request = NULL; + ccmsg_ccache_rem_creds_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -644,14 +716,17 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, request_header->creds = htonll(int_creds->handle); code = cci_msg_new(ccmsg_CCACHE_REM_CREDS, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_rem_creds_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -662,8 +737,14 @@ cc_int_ccache_remove_credentials( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -674,9 +755,9 @@ cc_int_ccache_move( cc_ccache_t source, { 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_msg_t *request = NULL; + ccmsg_ccache_move_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -698,18 +779,21 @@ cc_int_ccache_move( cc_ccache_t source, return ccErrNoMem; code = cci_msg_new(ccmsg_CCACHE_MOVE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_ccache_source->ctx); request_header->ccache_source = htonll(int_ccache_source->handle); request_header->ccache_dest = htonll(int_ccache_dest->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_move_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -720,8 +804,14 @@ cc_int_ccache_move( cc_ccache_t source, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -730,9 +820,9 @@ cc_int_ccache_lock( cc_ccache_t ccache, cc_uint32 block ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_lock_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_lock_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -752,18 +842,21 @@ cc_int_ccache_lock( cc_ccache_t ccache, return ccErrNoMem; code = cci_msg_new(ccmsg_CCACHE_LOCK, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_ccache->ctx); request_header->ccache = htonll(int_ccache->handle); request_header->lock_type = htonl(lock_type); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_lock_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -776,8 +869,14 @@ cc_int_ccache_lock( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -785,9 +884,9 @@ 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_msg_t *request = NULL; + ccmsg_ccache_unlock_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -804,17 +903,20 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) return ccErrNoMem; code = cci_msg_new(ccmsg_CCACHE_UNLOCK, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_ccache->ctx); request_header->ccache = htonll(int_ccache->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_unlock_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = htonl(response->type); if (type == ccmsg_NACK) { @@ -825,8 +927,14 @@ cc_int_ccache_unlock( cc_ccache_t ccache ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -836,9 +944,9 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, cc_time* time_offset ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_last_default_time_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_last_default_time_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_time64 t64; cc_int32 code; @@ -858,14 +966,17 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_LAST_DEFAULT_TIME, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_last_default_time_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -880,8 +991,14 @@ cc_int_ccache_get_last_default_time( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -889,9 +1006,9 @@ cc_int32 cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_change_time_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_change_time_t *request_header = NULL; + cc_msg_t *response = NULL; cc_time64 t64; cc_uint32 type; cc_int32 code; @@ -911,14 +1028,17 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time ) request_header->ccache = htonll(int_ccache->handle); code = cci_msg_new(ccmsg_CCACHE_GET_CHANGE_TIME, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_change_time_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -933,8 +1053,14 @@ cc_int_ccache_get_change_time( cc_ccache_t ccache, cc_time* time ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -945,9 +1071,9 @@ cc_int_ccache_compare( cc_ccache_t ccache, { 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_msg_t *request = NULL; + ccmsg_ccache_compare_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -969,14 +1095,17 @@ cc_int_ccache_compare( cc_ccache_t ccache, request_header->ccache2 = htonll(int_compare_to->handle); code = cci_msg_new(ccmsg_CCACHE_COMPARE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_compare_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -989,8 +1118,14 @@ cc_int_ccache_compare( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -1000,9 +1135,9 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, cc_time* time_offset ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_get_kdc_time_offset_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_get_kdc_time_offset_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -1022,14 +1157,17 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_GET_KDC_TIME_OFFSET, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_get_kdc_time_offset_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -1042,8 +1180,14 @@ cc_int_ccache_get_kdc_time_offset( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -1053,9 +1197,9 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, cc_time time_offset ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_set_kdc_time_offset_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_set_kdc_time_offset_t *request_header = NULL; + cc_msg_t *response = NULL; cc_int64 t64; cc_uint32 type; cc_int32 code; @@ -1078,14 +1222,17 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, request_header->offset = htonll(t64); code = cci_msg_new(ccmsg_CCACHE_SET_KDC_TIME_OFFSET, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_set_kdc_time_offset_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -1096,8 +1243,14 @@ cc_int_ccache_set_kdc_time_offset( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -1106,9 +1259,9 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, cc_int32 credentials_version ) { cc_int_ccache_t int_ccache; - cc_msg_t *request; - ccmsg_ccache_clear_kdc_time_offset_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_clear_kdc_time_offset_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -1128,14 +1281,17 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, request_header->creds_version = htonl(credentials_version); code = cci_msg_new(ccmsg_CCACHE_CLEAR_KDC_TIME_OFFSET, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_clear_kdc_time_offset_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -1146,7 +1302,13 @@ cc_int_ccache_clear_kdc_time_offset( cc_ccache_t ccache, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } diff --git a/src/lib/ccapi/client/ccache_iterator.c b/src/lib/ccapi/client/ccache_iterator.c index b0ccbe610..3da9b3547 100644 --- a/src/lib/ccapi/client/ccache_iterator.c +++ b/src/lib/ccapi/client/ccache_iterator.c @@ -58,7 +58,7 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter, cc_handle ctx, cc_handle handle ) { - cc_int_ccache_iterator_t iter; + cc_int_ccache_iterator_t iter = NULL; if ( piter == NULL ) return ccErrBadParam; @@ -68,7 +68,7 @@ cc_int_ccache_iterator_new( cc_ccache_iterator_t * piter, return ccErrNoMem; iter->functions = (cc_ccache_iterator_f*)malloc( sizeof(cc_ccache_iterator_f)); - if ( iter->functions ) { + if ( iter->functions == NULL ) { free(iter); return ccErrNoMem; } @@ -87,9 +87,9 @@ cc_int32 cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) { cc_int_ccache_iterator_t int_iter; - cc_msg_t *request; - ccmsg_ccache_iterator_release_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_iterator_release_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -108,14 +108,17 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) request_header->ctx = htonll(int_iter->ctx); request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CCACHE_ITERATOR_RELEASE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_release_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -126,11 +129,19 @@ cc_int_ccache_iterator_release( cc_ccache_iterator_t iter ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); - free(int_iter->functions); - free(int_iter); + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); + + if (int_iter->functions) + free(int_iter->functions); + if (iter) + free(int_iter); return ccNoError; } @@ -139,9 +150,9 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, cc_ccache_t * ccache ) { cc_int_ccache_iterator_t int_iter; - cc_msg_t *request; - ccmsg_ccache_iterator_next_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_iterator_next_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -160,14 +171,17 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CCACHE_ITERATOR_NEXT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_next_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -179,8 +193,14 @@ cc_int_ccache_iterator_next( cc_ccache_iterator_t iter, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -189,9 +209,9 @@ 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_msg_t *request = NULL; + ccmsg_ccache_iterator_clone_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -210,14 +230,17 @@ cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter, request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CCACHE_ITERATOR_CLONE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_iterator_clone_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -229,7 +252,13 @@ cc_int_ccache_iterator_clone( cc_ccache_iterator_t iter, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c index 8515f695b..8a79fcede 100644 --- a/src/lib/ccapi/client/context.c +++ b/src/lib/ccapi/client/context.c @@ -97,9 +97,9 @@ cc_int32 cc_int_context_release( cc_context_t context ) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_release_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_release_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -117,14 +117,17 @@ cc_int_context_release( cc_context_t context ) request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_RELEASE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_release_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -135,8 +138,14 @@ cc_int_context_release( cc_context_t context ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + request_header = NULL; + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); free(int_context->functions); free(int_context); return code; @@ -147,9 +156,9 @@ cc_int_context_get_change_time( cc_context_t context, cc_time* time) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_get_change_time_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_get_change_time_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ctx_get_change_time_resp_t *response_header; cc_time64 t64; cc_uint32 type; @@ -169,14 +178,17 @@ cc_int_context_get_change_time( cc_context_t context, request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_GET_CHANGE_TIME, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_change_time_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -191,8 +203,14 @@ cc_int_context_get_change_time( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -201,10 +219,11 @@ cc_int_context_get_default_ccache_name( cc_context_t context, cc_string_t* name ) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_get_default_ccache_name_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_get_default_ccache_name_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ctx_get_default_ccache_name_resp_t *response_header; + char *string = NULL; cc_uint32 type; cc_int32 code; @@ -222,33 +241,41 @@ cc_int_context_get_default_ccache_name( cc_context_t context, request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_GET_DEFAULT_CCACHE_NAME, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_get_default_ccache_name_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; 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) { - char * string; response_header = (ccmsg_ctx_get_default_ccache_name_resp_t*)response->header; code = cci_msg_retrieve_blob(response, response_header->name_offset, response_header->name_len, &string); - if (code == ccNoError) { + if (code == ccNoError) code = cci_string_new(name, string); - free(string); - } } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (string) + free(string); + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -258,9 +285,9 @@ cc_int_context_compare( cc_context_t context, cc_uint32* equal ) { cc_int_context_t int_context, int_compare_to; - cc_msg_t *request; - ccmsg_ctx_compare_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_compare_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ctx_compare_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -283,14 +310,17 @@ cc_int_context_compare( cc_context_t context, request_header->ctx2 = htonll(int_compare_to->handle); code = cci_msg_new(ccmsg_CTX_COMPARE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_compare_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -303,8 +333,14 @@ cc_int_context_compare( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -314,9 +350,9 @@ cc_int_context_new_ccache_iterator( cc_context_t context, cc_ccache_iterator_t* iterator ) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_new_ccache_iterator_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_new_ccache_iterator_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ctx_new_ccache_iterator_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -335,14 +371,17 @@ cc_int_context_new_ccache_iterator( cc_context_t context, request_header->ctx = htonll(int_context->handle); code = cci_msg_new(ccmsg_CTX_NEW_CCACHE_ITERATOR, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_new_ccache_iterator_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -355,8 +394,14 @@ cc_int_context_new_ccache_iterator( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -367,9 +412,9 @@ cc_int_context_open_ccache( cc_context_t context, { 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 *request = NULL; + ccmsg_ccache_open_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ccache_open_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -387,25 +432,25 @@ cc_int_context_open_ccache( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); request_header->name_offset = htonl(blob_pos); request_header->name_len = htonl(strlen(name) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -417,8 +462,14 @@ cc_int_context_open_ccache( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -427,9 +478,9 @@ cc_int_context_open_default_ccache( cc_context_t context, cc_ccache_t* ccache) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ccache_open_default_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ccache_open_default_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ccache_open_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -447,16 +498,19 @@ cc_int_context_open_default_ccache( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_CCACHE_OPEN_DEFAULT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_open_default_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -468,8 +522,14 @@ cc_int_context_open_default_ccache( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -482,9 +542,9 @@ cc_int_context_create_ccache( cc_context_t context, { 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 *request = NULL; + ccmsg_ccache_create_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ccache_create_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -504,17 +564,12 @@ cc_int_context_create_ccache( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_data_blob(request, (void *)name, strlen(name) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); request_header->version = htonl(cred_vers); @@ -522,17 +577,20 @@ cc_int_context_create_ccache( cc_context_t context, request_header->name_len = htonl(strlen(name) + 1); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; + request_header->principal_offset = htonl(blob_pos); request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -544,8 +602,14 @@ cc_int_context_create_ccache( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -557,9 +621,9 @@ cc_int_context_create_default_ccache( cc_context_t context, { 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 *request = NULL; + ccmsg_ccache_create_default_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ccache_create_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -579,26 +643,27 @@ cc_int_context_create_default_ccache( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_DEFAULT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); request_header->version = htonl(cred_vers); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; + request_header->principal_offset = htonl(blob_pos); request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_default_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -610,8 +675,14 @@ cc_int_context_create_default_ccache( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -623,9 +694,9 @@ cc_int_context_create_new_ccache( cc_context_t context, { 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 *request = NULL; + ccmsg_ccache_create_unique_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ccache_create_resp_t *response_header; cc_uint32 type; cc_int32 code; @@ -645,26 +716,27 @@ cc_int_context_create_new_ccache( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_CCACHE_CREATE_UNIQUE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); request_header->version = htonl(cred_vers); code = cci_msg_add_data_blob(request, (void *)principal, strlen(principal) + 1, &blob_pos); - if (code != ccNoError) { - cci_msg_destroy(request); - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; + request_header->principal_offset = htonl(blob_pos); request_header->principal_len = htonl(strlen(principal) + 1); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ccache_create_unique_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = htonl(response->type); if (type == ccmsg_NACK) { @@ -676,8 +748,14 @@ cc_int_context_create_new_ccache( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -687,9 +765,9 @@ cc_int_context_lock( cc_context_t context, cc_uint32 block ) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_lock_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_lock_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -709,17 +787,20 @@ cc_int_context_lock( cc_context_t context, return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_LOCK, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); request_header->lock_type = htonl(lock_type); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_lock_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -732,8 +813,14 @@ cc_int_context_lock( cc_context_t context, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -741,9 +828,9 @@ cc_int32 cc_int_context_unlock( cc_context_t context ) { cc_int_context_t int_context; - cc_msg_t *request; - ccmsg_ctx_unlock_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_unlock_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -760,16 +847,19 @@ cc_int_context_unlock( cc_context_t context ) return ccErrNoMem; code = cci_msg_new(ccmsg_CTX_UNLOCK, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; request_header->ctx = htonll(int_context->handle); code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_unlock_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -780,8 +870,14 @@ cc_int_context_unlock( cc_context_t context ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -794,10 +890,11 @@ cc_int_context_clone( cc_context_t inContext, { cc_int_context_t int_context; static char vendor_st[128] = ""; - cc_msg_t *request; - ccmsg_ctx_clone_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_ctx_clone_t *request_header = NULL; + cc_msg_t *response = NULL; ccmsg_ctx_clone_resp_t *response_header; + char *string = NULL; cc_uint32 type; cc_int32 code; @@ -831,14 +928,17 @@ cc_int_context_clone( cc_context_t inContext, request_header->in_version = htonl(requestedVersion); code = cci_msg_new(ccmsg_INIT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_ctx_clone_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -850,11 +950,9 @@ cc_int_context_clone( cc_context_t inContext, code = cc_int_context_new(outContext, ntohll(response_header->out_ctx), ntohl(response_header->out_version)); if (!vendor_st[0]) { - char * string; code = cci_msg_retrieve_blob(response, ntohl(response_header->vendor_offset), ntohl(response_header->vendor_length), &string); strncpy(vendor_st, string, sizeof(vendor_st)-1); vendor_st[sizeof(vendor_st)-1] = '\0'; - free(string); } *vendor = vendor_st; @@ -862,8 +960,16 @@ cc_int_context_clone( cc_context_t inContext, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (string) + free(string); + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } diff --git a/src/lib/ccapi/client/credentials_iterator.c b/src/lib/ccapi/client/credentials_iterator.c index f61d0ade8..3cdab875a 100644 --- a/src/lib/ccapi/client/credentials_iterator.c +++ b/src/lib/ccapi/client/credentials_iterator.c @@ -90,9 +90,9 @@ cc_int32 cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) { cc_int_credentials_iterator_t int_iter; - cc_msg_t *request; - ccmsg_creds_iterator_release_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_creds_iterator_release_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -112,14 +112,17 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CREDS_ITERATOR_RELEASE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_release_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = htonl(response->type); if (type == ccmsg_NACK) { @@ -130,8 +133,14 @@ cc_int_credentials_iterator_release( cc_credentials_iterator_t iter ) } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); free(int_iter->functions); free(int_iter); @@ -143,9 +152,9 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, cc_credentials_t * credentials ) { cc_int_credentials_iterator_t int_iter; - cc_msg_t *request; - ccmsg_creds_iterator_next_t *request_header; - cc_msg_t *response; + cc_msg_t *request = NULL; + ccmsg_creds_iterator_next_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -165,14 +174,17 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CREDS_ITERATOR_NEXT, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_next_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -189,8 +201,14 @@ cc_int_credentials_iterator_next( cc_credentials_iterator_t iter, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } @@ -199,9 +217,9 @@ 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_msg_t *request = NULL; + ccmsg_creds_iterator_clone_t *request_header = NULL; + cc_msg_t *response = NULL; cc_uint32 type; cc_int32 code; @@ -220,14 +238,17 @@ cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter, request_header->iterator = htonll(int_iter->handle); code = cci_msg_new(ccmsg_CREDS_ITERATOR_CLONE, &request); - if (code != ccNoError) { - free(request_header); - return code; - } + if (code != ccNoError) + goto cleanup; code = cci_msg_add_header(request, request_header, sizeof(ccmsg_creds_iterator_clone_t)); + if (code != ccNoError) + goto cleanup; + request_header = NULL; code = cci_perform_rpc(request, &response); + if (code != ccNoError) + goto cleanup; type = ntohl(response->type); if (type == ccmsg_NACK) { @@ -239,8 +260,14 @@ cc_int_credentials_iterator_clone( cc_credentials_iterator_t iter, } else { code = ccErrBadInternalMessage; } - cci_msg_destroy(request); - cci_msg_destroy(response); + + cleanup: + if (request_header) + free(request_header); + if (request) + cci_msg_destroy(request); + if (response) + cci_msg_destroy(response); return code; } -- cgit From 350cfced455d45368065095201bc2f674093cf41 Mon Sep 17 00:00:00 2001 From: Alexandra Ellwood Date: Fri, 9 Jun 2006 21:57:20 +0000 Subject: Include string.h to get memcpy, strlen, etc on BSD OSes git-svn-id: svn://anonsvn.mit.edu/krb5/branches/ccapi@18098 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/ccapi/client/cacheapi.c | 1 + src/lib/ccapi/client/ccache.c | 1 + src/lib/ccapi/client/context.c | 1 + 3 files changed, 3 insertions(+) (limited to 'src/lib/ccapi/client') diff --git a/src/lib/ccapi/client/cacheapi.c b/src/lib/ccapi/client/cacheapi.c index c76ebe457..89c5e63d1 100644 --- a/src/lib/ccapi/client/cacheapi.c +++ b/src/lib/ccapi/client/cacheapi.c @@ -43,6 +43,7 @@ #include #include +#include #include #include "ccache.h" #include "ccache_iterator.h" diff --git a/src/lib/ccapi/client/ccache.c b/src/lib/ccapi/client/ccache.c index e4b9673c7..07e9b8e87 100644 --- a/src/lib/ccapi/client/ccache.c +++ b/src/lib/ccapi/client/ccache.c @@ -46,6 +46,7 @@ #include #include +#include #include #include "credentials.h" #include "credentials_iterator.h" diff --git a/src/lib/ccapi/client/context.c b/src/lib/ccapi/client/context.c index 8a79fcede..5d88d4686 100644 --- a/src/lib/ccapi/client/context.c +++ b/src/lib/ccapi/client/context.c @@ -45,6 +45,7 @@ #include #include +#include #include #include "context.h" #include "ccache.h" -- cgit