自学教程：C++ AXIS2_MALLOC函数代码示例

AXIS2_EXTERN sandesha2_address_t* AXIS2_CALLsandesha2_address_create(    const axutil_env_t *env,     axis2_char_t *ns_val, 	axis2_endpoint_ref_t *epr){    sandesha2_address_t *address = NULL;    AXIS2_PARAM_CHECK(env->error, ns_val, NULL);        address =  (sandesha2_address_t *)AXIS2_MALLOC         (env->allocator, sizeof(sandesha2_address_t));	    if(!address)	{		AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;	}    address->ns_val = axutil_strdup(env, ns_val);    address->epr = epr;    	return address;}

AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALLaxis2_svc_grp_builder_create(    const axutil_env_t * env){    axis2_svc_grp_builder_t *svc_grp_builder = NULL;    AXIS2_ENV_CHECK(env, NULL);    svc_grp_builder = (axis2_svc_grp_builder_t *)AXIS2_MALLOC(env->allocator,        sizeof(axis2_svc_grp_builder_t));    if(!svc_grp_builder)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    svc_grp_builder->svc_grp = NULL;    svc_grp_builder->desc_builder = NULL;    return svc_grp_builder;}

AXIS2_EXTERN axiom_mime_part_t *AXIS2_CALLaxiom_mime_part_create(    const axutil_env_t *env){    axiom_mime_part_t *mime_part = NULL;    mime_part = AXIS2_MALLOC(env->allocator, sizeof(axiom_mime_part_t));    if(mime_part)    {        mime_part->part = NULL;        mime_part->file_name = NULL;        mime_part->part_size = 0;        mime_part->type = AXIOM_MIME_PART_UNKNOWN;        mime_part->user_param = NULL;        return mime_part;    }    else    {        return NULL;    }}

AXIS2_EXTERN axutil_stream_t *AXIS2_CALLaxutil_stream_create_internal(    const axutil_env_t *env){    axutil_stream_t *stream = NULL;    stream = (axutil_stream_t *)AXIS2_MALLOC(env->allocator, sizeof(axutil_stream_t));    if(!stream)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory. Cannot create axutil stream");        return NULL;    }    stream->buffer = NULL;    stream->buffer_head = NULL;    stream->fp = NULL;    stream->socket = -1;    stream->len = -1;    stream->max_len = -1;    stream->axis2_eof = EOF;    return stream;}

int AXIS2_CALLaxutil_stream_read_socket(    axutil_stream_t *stream,    const axutil_env_t *env,    void *buffer,    size_t count){    int len = 0;    if(-1 == stream->socket)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOCKET, AXIS2_FAILURE);        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,            "Trying to do operation on closed/not-opened socket");        return -1;    }    if(!buffer)    {        return -1;    }    len = (int)recv(stream->socket, buffer, (int)count, 0);    /* We are sure that the difference lies within the int range */#ifdef AXIS2_TCPMON    if (len > 1)    {        axis2_char_t *temp = NULL;        temp = (axis2_char_t *) AXIS2_MALLOC(env->allocator, (len + 1) * sizeof(axis2_char_t));        if (temp)        {            memcpy(temp, buffer, len * sizeof(axis2_char_t));            temp[len] = '/0';            fprintf(stderr, "%s", temp);            AXIS2_FREE(env->allocator, temp);        }    }#endif    return len;}

int main(){    axis2_char_t* hash = NULL;    axutil_env_t *env = NULL;    axis2_char_t* nonce = NULL;    axis2_char_t* created = NULL;    env = test_init();    printf("--Testing started--------------------------------------------/n");    printf("/n--Testing hash-----------------------------------------------/n");    hash = rampart_crypto_sha1(env, "WScqanjCEAC4mQoBE07sAQ==", "2003-07-16T01:24:32Z", "IloveDogs");    if (!hash)    {        printf("No hash generated :( .../n");    }    printf("Hash = %s", hash);#if 0    /*encode Base64*/    axis2_char_t* encodedStr = NULL;    encodedStr = AXIS2_MALLOC(env->allocator, 20);    axutil_base64_encode_binary(encodedStr, hash, 20);    printf("Hash = %s /n", encodedStr);#endif    printf("/n----Testing nonce------------------------------------------/n");    nonce = rampart_generate_nonce(env);    printf("NONCE: %s", nonce);    printf("/n----Testing created----------------------------------------/n");    created = rampart_generate_time(env, 300);    printf("CREATED: %s", created);    printf("/n----End of testings----------------------------------------/n");    return 0;}

//-----------------------------------------------------------------------------// Reads a binary image from the file fp.// The file should be composed of HTTP mime messages as received in the form of// an HTTP response. fp is already positioned at the start of the image.// The boundary is given by boundId.//char * rp_read_bin_mime_image(    const axutil_env_t * env,    FILE *fp,    const char *boundId,    int *len){    char     *image_binary   = NULL;    int      actual_filled   = 0;    TmpStore             *ts = NULL;    axutil_linked_list_t *ll = axutil_linked_list_create(env);    *len = 0;    Rp_cb_ctx fill_ctx;    init_rp_cb_ctx(env, &fill_ctx);    fill_ctx.fp    = fp;    fill_ctx.bound = boundId;    while (!fill_ctx.done)    {        ts = (TmpStore *)AXIS2_MALLOC(env->allocator, sizeof(TmpStore));        actual_filled = rp_fill_buff_CB(ts->buf, SP_IMG_BUF_SIZE, &fill_ctx);        if (0 == actual_filled)        {            AXIS2_FREE(env->allocator, ts);            break;        }        ts->size = actual_filled;        *len    += actual_filled;        axutil_linked_list_add (ll, env, (void *)ts);    }    image_binary = compose_buffer(env, *len, ll);    axutil_linked_list_free(ll, env);    return image_binary;}

axis2_endpoint_ref_t *AXIS2_CALLaxis2_endpoint_ref_create(    const axutil_env_t * env,    const axis2_char_t * address){    axis2_endpoint_ref_t *endpoint_ref = NULL;    AXIS2_ENV_CHECK(env, NULL);    endpoint_ref = AXIS2_MALLOC(env->allocator, sizeof(axis2_endpoint_ref_t));    if (!endpoint_ref)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    endpoint_ref->address = NULL;    endpoint_ref->interface_qname = NULL;    endpoint_ref->ref_param_list = NULL;    endpoint_ref->metadata_list = NULL;    endpoint_ref->ref_attribute_list = NULL;    endpoint_ref->meta_attribute_list = NULL;    endpoint_ref->extension_list = NULL;    endpoint_ref->svc_name = NULL;    if (address)    {        endpoint_ref->address = axutil_strdup(env, address);        if (!(endpoint_ref->address))        {            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);            axis2_endpoint_ref_free(endpoint_ref, env);            return NULL;        }    }    return endpoint_ref;}

int AXIS2_CALLopenssl_rsa_pub_decrypt(    const axutil_env_t *env,    const openssl_pkey_t *pkey,    const axis2_char_t *padding,    oxs_buffer_t *in,    oxs_buffer_t *out){    unsigned char *decrypted = NULL;    int ret;    EVP_PKEY *key = NULL;    int pad = RSA_PKCS1_PADDING;    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);    key = (EVP_PKEY *)openssl_pkey_get_key(pkey, env);    if(0 == axutil_strcmp(padding, OPENSSL_RSA_PKCS1_OAEP_PADDING  ) ){        pad = RSA_PKCS1_OAEP_PADDING;    }else if(0 == axutil_strcmp(padding, OPENSSL_RSA_PKCS1_PADDING  ) ){        pad = RSA_PKCS1_PADDING;    }    decrypted = AXIS2_MALLOC(env->allocator, RSA_size(key->pkey.rsa));    ret = RSA_public_decrypt(oxs_buffer_get_size(in, env),                             oxs_buffer_get_data(in, env),                             decrypted,                             key->pkey.rsa ,                             pad);    if (ret < 0)    {        oxs_error(env, OXS_ERROR_LOCATION, OXS_ERROR_OPENSSL_FUNC_FAILED,                  "PUBKEY decrypt (signature verification) failed");        return (-1);    }    oxs_buffer_populate(out, env, decrypted, ret);    return ret;}

       /************************* Function Implmentations ********************************/        adb_importCertToStore_t* AXIS2_CALL        adb_importCertToStore_create(            const axutil_env_t *env)        {            adb_importCertToStore_t *_importCertToStore = NULL;                            axutil_qname_t* qname = NULL;                        AXIS2_ENV_CHECK(env, NULL);            _importCertToStore = (adb_importCertToStore_t *) AXIS2_MALLOC(env->                allocator, sizeof(adb_importCertToStore_t));            if(NULL == _importCertToStore)            {                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);                return NULL;            }            memset(_importCertToStore, 0, sizeof(adb_importCertToStore_t));            _importCertToStore->property_Type = axutil_strdup(env, "adb_importCertToStore");            _importCertToStore->property_fileName  = NULL;                  _importCertToStore->is_valid_fileName  = AXIS2_FALSE;            _importCertToStore->property_fileData  = NULL;                  _importCertToStore->is_valid_fileData  = AXIS2_FALSE;            _importCertToStore->property_keyStoreName  = NULL;                  _importCertToStore->is_valid_keyStoreName  = AXIS2_FALSE;                              qname =  axutil_qname_create (env,                        "importCertToStore",                        "http://service.keystore.security.carbon.wso2.org",                        NULL);                _importCertToStore->qname = qname;                        return _importCertToStore;        }

int AXIS2_CALLaxutil_stream_write_basic(    axutil_stream_t *stream,    const axutil_env_t *env,    const void *buffer,    size_t count){    int new_len = 0;    if(!buffer)        return -1;    new_len = (int)(stream->len + count);    /* We are sure that the difference lies within the int range */    if(new_len > stream->max_len)    {        axis2_char_t *tmp = (axis2_char_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t)            * (new_len + AXIS2_STREAM_DEFAULT_BUF_SIZE));        if(!tmp)        {            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);            return -1;        }        /*         * pre allocation: extra AXIS2_STREAM_DEFAULT_BUF_SIZE more bytes          * allocated          */        stream->max_len = new_len + AXIS2_STREAM_DEFAULT_BUF_SIZE;        memcpy(tmp, stream->buffer, sizeof(axis2_char_t) * stream->len);        AXIS2_FREE(env->allocator, stream->buffer_head);        stream->buffer = tmp;        stream->buffer_head = tmp;    }    memcpy(stream->buffer + (stream->len * sizeof(axis2_char_t)), buffer, count);    stream->len += (int)count;    /* We are sure that the difference lies within the int range */    return (int)count;}

AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALLaxis2_ws_info_list_create_with_dep_engine(    const axutil_env_t * env,    struct axis2_dep_engine *dep_engine){    axis2_ws_info_list_t *ws_info_list = NULL;    ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator,        sizeof(axis2_ws_info_list_t));    if(!ws_info_list)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t));    ws_info_list->dep_engine = dep_engine;    ws_info_list->ws_info_list = axutil_array_list_create(env, 0);    if(!(ws_info_list->ws_info_list))    {        axis2_ws_info_list_free(ws_info_list, env);        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    ws_info_list->current_info_list = axutil_array_list_create(env, 0);    if(!(ws_info_list->current_info_list))    {        axis2_ws_info_list_free(ws_info_list, env);        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    return ws_info_list;}

AXIS2_EXTERN sandesha2_seq_report_t * AXIS2_CALLsandesha2_seq_report_create(    const axutil_env_t *env){    sandesha2_seq_report_t *report = NULL;    AXIS2_ENV_CHECK(env, NULL);    report = AXIS2_MALLOC(env->allocator,         sizeof(sandesha2_seq_report_t));    report->seq_status = SANDESHA2_SEQ_STATUS_UNKNOWN;    report->seq_direction = SANDESHA2_SEQ_DIRECTION_UNKNOWN;    report->completed_msgs = NULL;    report->internal_seq_id = NULL;    report->seq_id = NULL;    report->completed_msgs = axutil_array_list_create(env, 0);    if(!report->completed_msgs)     {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    return report;}

AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALLrp_transport_binding_create(    const axutil_env_t * env){    rp_transport_binding_t *transport_binding = NULL;    AXIS2_ENV_CHECK(env, NULL);    transport_binding = (rp_transport_binding_t *)AXIS2_MALLOC(env->allocator,        sizeof(rp_transport_binding_t));    if(transport_binding == NULL)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    transport_binding->binding_commons = NULL;    transport_binding->transport_token = NULL;    transport_binding->ref = 0;    return transport_binding;}

AXIS2_EXTERN remote_registry_comment_t* AXIS2_CALLremote_registry_comment_create(    const axutil_env_t *env){    remote_registry_comment_t *comment = NULL;       comment =  (remote_registry_comment_t *)AXIS2_MALLOC(env->allocator,             sizeof(remote_registry_comment_t));	    if(!comment)	{		AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;	}    comment->resource_path = NULL;    comment->comment_path = NULL;    comment->text = NULL;    comment->user = NULL;    comment->date_time = NULL;	return comment;}

AXIS2_EXTERN oxs_sign_part_t *AXIS2_CALLoxs_sign_part_create(const axutil_env_t *env){    oxs_sign_part_t *sign_part = NULL;    AXIS2_ENV_CHECK(env, NULL);    sign_part = AXIS2_MALLOC(env->allocator, sizeof(oxs_sign_part_t));    if (!sign_part)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    sign_part->id= NULL;    sign_part->digest_mtd = NULL;    sign_part->digest_val = NULL;    sign_part->node = NULL;    sign_part->transforms = NULL;	sign_part->id_name = NULL;	sign_part->sig_ns = NULL;    return sign_part;}

AXIS2_EXTERN trust_rstr_t * AXIS2_CALLtrust_rstr_create(        const axutil_env_t *env){    trust_rstr_t *rstr = NULL;        rstr = (trust_rstr_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_rstr_t));        rstr->token_type = NULL;    rstr->attr_context = NULL;    rstr->request_type = NULL;    rstr->requested_sec_token = NULL;    rstr->applies_to = NULL;    rstr->requested_attached_ref = NULL;    rstr->requested_unattached_ref = NULL;    rstr->requested_proof_token = NULL;    rstr->entropy = NULL;    rstr->life_time = NULL;    rstr->key_size = -1;    rstr->wst_ns_uri = NULL;        return rstr;}

AXIS2_EXTERN rampart_config_t *AXIS2_CALLrampart_config_create(    const axutil_env_t *env){    rampart_config_t *rampart_config = NULL;    rampart_config =  (rampart_config_t *) AXIS2_MALLOC (env->allocator, sizeof (rampart_config_t));    if(!rampart_config)    {        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,             "[rampart] Unable to create rampart configuration. Insufficient memory.");        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    rampart_config->username = NULL;    rampart_config->password = NULL;    rampart_config->password_type = NULL;    rampart_config->ttl = 0;    rampart_config->saml_tokens = NULL;	rampart_config->issued_token_aquire = NULL;    return rampart_config;}

AXIS2_EXTERN axiom_soap_fault_code_t *AXIS2_CALLaxiom_soap_fault_code_create(    const axutil_env_t * env){    axiom_soap_fault_code_t *fault_code = NULL;    fault_code = (axiom_soap_fault_code_t *)AXIS2_MALLOC(env->allocator,                 sizeof(axiom_soap_fault_code_t));    if(!fault_code)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create SOAP fault code");        return NULL;    }    fault_code->om_ele_node = NULL;    fault_code->subcode = NULL;    fault_code->value = NULL;    fault_code->builder = NULL;    fault_code->soap_version = AXIOM_SOAP_VERSION_NOT_SET;    return fault_code;}

AXIS2_EXTERN axutil_linked_list_t *AXIS2_CALLaxutil_linked_list_create(    const axutil_env_t *env){    axutil_linked_list_t *linked_list = NULL;    AXIS2_ENV_CHECK(env, NULL);    linked_list = AXIS2_MALLOC(env->allocator, sizeof(axutil_linked_list_t));    if (!linked_list)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");        return NULL;    }    linked_list->size = 0;    linked_list->mod_count = 0;    linked_list->first = NULL;    linked_list->last = NULL;    return linked_list;}

AXIS2_EXTERN axutil_log_t *AXIS2_CALLaxutil_log_create_default(    axutil_allocator_t *allocator){    axutil_log_impl_t *log_impl;    if (!allocator)        return NULL;    log_impl = (axutil_log_impl_t *) AXIS2_MALLOC(allocator,                   sizeof(axutil_log_impl_t));    if (!log_impl)        return NULL;    log_impl->mutex =        axutil_thread_mutex_create(allocator, AXIS2_THREAD_MUTEX_DEFAULT);    if (!log_impl->mutex)    {        fprintf(stderr, "cannot create log mutex /n");        return NULL;    }    axutil_thread_mutex_lock(log_impl->mutex);    log_impl->file_name = NULL;    log_impl->log.size = AXUTIL_LOG_FILE_SIZE;    log_impl->stream = stderr;    axutil_thread_mutex_unlock(log_impl->mutex);    /* by default, log is enabled */    log_impl->log.enabled = 1;    log_impl->log.level = AXIS2_LOG_LEVEL_DEBUG;    log_impl->log.ops = &axutil_log_ops_var;    return &(log_impl->log);}

AXIS2_EXTERN const axis2_char_t *AXIS2_CALLaxiom_text_get_text(    axiom_text_t * om_text,    const axutil_env_t * env){    AXIS2_ENV_CHECK(env, NULL);    AXIS2_PARAM_CHECK(env->error, om_text, NULL);    if(om_text->value)    {        return axutil_string_get_buffer(om_text->value, env);    }    else    {        axis2_char_t *data_handler_stream = NULL;        size_t data_handler_stream_size = 0;        if(om_text->data_handler)        {            size_t encoded_len = 0;            axis2_char_t *encoded_str = NULL;            axiom_data_handler_read_from(om_text->data_handler, env, &data_handler_stream,                &data_handler_stream_size);            if(data_handler_stream)            {                encoded_len = (size_t)axutil_base64_encode_len((int)data_handler_stream_size);                encoded_str = AXIS2_MALLOC(env->allocator, encoded_len + 2);                if(encoded_str)                {                    encoded_len = (size_t)axutil_base64_encode(encoded_str, data_handler_stream,                        (int)data_handler_stream_size);                    encoded_str[encoded_len] = '/0';                    return encoded_str;                }            }        }    }    return NULL;}

AXIS2_EXTERN axiom_soap12_builder_helper_t *AXIS2_CALLaxiom_soap12_builder_helper_create(    const axutil_env_t * env,    axiom_soap_builder_t * soap_builder){    axiom_soap12_builder_helper_t *builder_helper = NULL;    AXIS2_ENV_CHECK(env, NULL);    AXIS2_PARAM_CHECK(env->error, soap_builder, NULL);    builder_helper =        (axiom_soap12_builder_helper_t *) AXIS2_MALLOC(env->allocator,                  sizeof(axiom_soap12_builder_helper_t));    if (!builder_helper)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,                  "No memory. Cannot create SOAP 1.1 builder helper");        return NULL;    }    builder_helper->code_present = AXIS2_FALSE;    builder_helper->detail_present = AXIS2_FALSE;    builder_helper->reason_present = AXIS2_FALSE;    builder_helper->role_present = AXIS2_FALSE;    builder_helper->sub_code_present = AXIS2_FALSE;    builder_helper->reason_processing = AXIS2_FALSE;    builder_helper->code_processing = AXIS2_FALSE;    builder_helper->sub_code_processing = AXIS2_FALSE;    builder_helper->detail_element_names = NULL;    builder_helper->node_present = AXIS2_FALSE;    builder_helper->soap_builder = soap_builder;    builder_helper->sub_sub_code_present = AXIS2_FALSE;    builder_helper->value_present = AXIS2_FALSE;    builder_helper->subcode_value_present = AXIS2_FALSE;    return builder_helper;}

       /************************* Function Implmentations ********************************/        adb_updateSystemLog_t* AXIS2_CALL        adb_updateSystemLog_create(            const axutil_env_t *env)        {            adb_updateSystemLog_t *_updateSystemLog = NULL;                            axutil_qname_t* qname = NULL;                        AXIS2_ENV_CHECK(env, NULL);            _updateSystemLog = (adb_updateSystemLog_t *) AXIS2_MALLOC(env->                allocator, sizeof(adb_updateSystemLog_t));            if(NULL == _updateSystemLog)            {                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);                return NULL;            }            memset(_updateSystemLog, 0, sizeof(adb_updateSystemLog_t));            _updateSystemLog->property_Type = axutil_strdup(env, "adb_updateSystemLog");            _updateSystemLog->property_logLevel  = NULL;                  _updateSystemLog->is_valid_logLevel  = AXIS2_FALSE;            _updateSystemLog->property_logPattern  = NULL;                  _updateSystemLog->is_valid_logPattern  = AXIS2_FALSE;            _updateSystemLog->is_valid_persist  = AXIS2_FALSE;                              qname =  axutil_qname_create (env,                        "updateSystemLog",                        "http://org.apache.axis2/xsd",                        NULL);                _updateSystemLog->qname = qname;                        return _updateSystemLog;        }

       /************************* Function Implmentations ********************************/        adb_getOperationRequestCount_t* AXIS2_CALL        adb_getOperationRequestCount_create(            const axutil_env_t *env)        {            adb_getOperationRequestCount_t *_getOperationRequestCount = NULL;                            axutil_qname_t* qname = NULL;                        AXIS2_ENV_CHECK(env, NULL);            _getOperationRequestCount = (adb_getOperationRequestCount_t *) AXIS2_MALLOC(env->                allocator, sizeof(adb_getOperationRequestCount_t));            if(NULL == _getOperationRequestCount)            {                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);                return NULL;            }            memset(_getOperationRequestCount, 0, sizeof(adb_getOperationRequestCount_t));            _getOperationRequestCount->property_Type = axutil_strdup(env, "adb_getOperationRequestCount");            _getOperationRequestCount->property_serviceName  = NULL;                  _getOperationRequestCount->is_valid_serviceName  = AXIS2_FALSE;            _getOperationRequestCount->property_operationName  = NULL;                  _getOperationRequestCount->is_valid_operationName  = AXIS2_FALSE;                              qname =  axutil_qname_create (env,                        "getOperationRequestCount",                        "http://org.apache.axis2/xsd",                        NULL);                _getOperationRequestCount->qname = qname;                        return _getOperationRequestCount;        }

       /************************* Function Implmentations ********************************/        adb_addExposedTransports_t* AXIS2_CALL        adb_addExposedTransports_create(            const axutil_env_t *env)        {            adb_addExposedTransports_t *_addExposedTransports = NULL;                            axutil_qname_t* qname = NULL;                        AXIS2_ENV_CHECK(env, NULL);            _addExposedTransports = (adb_addExposedTransports_t *) AXIS2_MALLOC(env->                allocator, sizeof(adb_addExposedTransports_t));            if(NULL == _addExposedTransports)            {                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);                return NULL;            }            memset(_addExposedTransports, 0, sizeof(adb_addExposedTransports_t));            _addExposedTransports->property_Type = axutil_strdup(env, "adb_addExposedTransports");            _addExposedTransports->property_serviceName  = NULL;                  _addExposedTransports->is_valid_serviceName  = AXIS2_FALSE;            _addExposedTransports->property_transport  = NULL;                  _addExposedTransports->is_valid_transport  = AXIS2_FALSE;                              qname =  axutil_qname_create (env,                        "addExposedTransports",                        "http://org.apache.axis2/xsd",                        NULL);                _addExposedTransports->qname = qname;                        return _addExposedTransports;        }

AXIS2_EXTERN rp_issued_token_t * AXIS2_CALLrp_issued_token_create(    const axutil_env_t *env){    rp_issued_token_t *issued_token = NULL;    issued_token = (rp_issued_token_t*)AXIS2_MALLOC(env->allocator, sizeof(rp_issued_token_t));    if(issued_token == NULL)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    issued_token->inclusion = NULL;    issued_token->issuer_epr = NULL;    issued_token->requested_sec_token_template = NULL;    issued_token->derivedkeys = AXIS2_FALSE;    issued_token->require_external_reference = AXIS2_FALSE;    issued_token->require_internal_reference = AXIS2_FALSE;    issued_token->ref = 0;    return issued_token;}

AXIS2_EXTERN sandesha2_report_t * AXIS2_CALLsandesha2_report_create(    const axutil_env_t *env){    sandesha2_report_t *report = NULL;    AXIS2_ENV_CHECK(env, NULL);    report = AXIS2_MALLOC(env->allocator,         sizeof(sandesha2_report_t));    report->incoming_seq_list = NULL;    report->outgoing_seq_list = NULL;    report->seq_status_map = NULL;    report->no_of_completed_msgs_map = NULL;    report->outgoing_internal_seq_id_map = NULL;    report->incoming_seq_list = axutil_array_list_create(env, 0);    report->outgoing_seq_list = axutil_array_list_create(env, 0);    if(!report->incoming_seq_list ||       !report->outgoing_seq_list)     {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    report->seq_status_map = axutil_hash_make(env);    report->no_of_completed_msgs_map = axutil_hash_make(env);    report->outgoing_internal_seq_id_map = axutil_hash_make(env);    if(!report->seq_status_map ||        !report->no_of_completed_msgs_map ||        !report->outgoing_internal_seq_id_map)     {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    return report;}

AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALLrp_symmetric_binding_create(    const axutil_env_t * env){    rp_symmetric_binding_t *symmetric_binding = NULL;    AXIS2_ENV_CHECK(env, NULL);    symmetric_binding = (rp_symmetric_binding_t *)AXIS2_MALLOC(env->allocator,                        sizeof(rp_symmetric_binding_t));    if(symmetric_binding == NULL)    {        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);        return NULL;    }    symmetric_binding->symmetric_asymmetric_binding_commons = NULL;    symmetric_binding->protection_token = NULL;    symmetric_binding->signature_token = NULL;    symmetric_binding->encryption_token = NULL;    symmetric_binding->ref = 0;    return symmetric_binding;}