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; }
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; }
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; }
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; } }
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; }
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; }
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_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; }
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; }
/************************* 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_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; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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); }
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; }
/************************* 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_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; }
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; }
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; }