Пример #1
0
static axis2_status_t AXIS2_CALL
axis2_udp_transport_add_backchannel_info(const axutil_env_t *env, axis2_ctx_t *ctx, axis2_socket_t socket)
{
	axis2_udp_backchannel_info_t *binfo = NULL;
	axutil_property_t *prop = NULL;
	binfo = AXIS2_MALLOC(env->allocator, sizeof(axis2_udp_backchannel_info_t));
	if (!binfo)
	{
		AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory");
		return AXIS2_FAILURE;
	}
	/* We set the axis2_svc and oparation. When the response comes it will bypass the dispatchers 
	   and will directly go the service and operation 
	   */
	binfo->op = NULL;
	binfo->svc = NULL;
	binfo->socket = socket;
	prop = axutil_property_create(env);
	axutil_property_set_value(prop, env, binfo);
	axis2_ctx_set_property(ctx, env, AXIS2_UDP_BACKCHANNEL_INFO, prop);
	return AXIS2_SUCCESS;
}
Пример #2
0
AXIS2_EXTERN sandesha2_address_t* AXIS2_CALL
sandesha2_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;
}
Пример #3
0
AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL
axis2_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;
}
Пример #4
0
AXIS2_EXTERN axiom_mime_part_t *AXIS2_CALL
axiom_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;
    }
}
Пример #5
0
AXIS2_EXTERN axutil_stream_t *AXIS2_CALL
axutil_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;
}
Пример #6
0
int AXIS2_CALL
axutil_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;
}
Пример #7
0
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;
}
Пример #8
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;
}
Пример #9
0
axis2_endpoint_ref_t *AXIS2_CALL
axis2_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;
}
Пример #10
0
int AXIS2_CALL
openssl_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;
}
Пример #11
0
       /************************* 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;
        }
Пример #12
0
int AXIS2_CALL
axutil_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;
}
Пример #13
0
AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL
axis2_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;
}
Пример #14
0
AXIS2_EXTERN sandesha2_seq_report_t * AXIS2_CALL
sandesha2_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;
}
Пример #15
0
AXIS2_EXTERN rp_transport_binding_t *AXIS2_CALL
rp_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;

}
Пример #16
0
AXIS2_EXTERN remote_registry_comment_t* AXIS2_CALL
remote_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;
}
Пример #17
0
AXIS2_EXTERN oxs_sign_part_t *AXIS2_CALL
oxs_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;
}
Пример #18
0
AXIS2_EXTERN trust_rstr_t * AXIS2_CALL
trust_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;
}
Пример #19
0
AXIS2_EXTERN rampart_config_t *AXIS2_CALL
rampart_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;
}
Пример #20
0
AXIS2_EXTERN axiom_soap_fault_code_t *AXIS2_CALL
axiom_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;
}
Пример #21
0
AXIS2_EXTERN axutil_linked_list_t *AXIS2_CALL
axutil_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;
}
Пример #22
0
AXIS2_EXTERN axutil_log_t *AXIS2_CALL
axutil_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);
}
Пример #23
0
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
axiom_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_CALL
axiom_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;
}
Пример #25
0
       /************************* 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;
        }
Пример #26
0
       /************************* 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;
        }
Пример #27
0
       /************************* 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;
        }
Пример #28
0
AXIS2_EXTERN rp_issued_token_t * AXIS2_CALL
rp_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;
}
Пример #29
0
AXIS2_EXTERN sandesha2_report_t * AXIS2_CALL
sandesha2_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;
}
Пример #30
0
AXIS2_EXTERN rp_symmetric_binding_t *AXIS2_CALL
rp_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;
}