| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| #include <axis2_util.h> |
| #include <oxs_utility.h> |
| #include <oxs_error.h> |
| #include <oxs_buffer.h> |
| #include <oxs_asym_ctx.h> |
| #include <openssl_util.h> |
| #include <oxs_key_mgr.h> |
| |
| AXIS2_EXTERN axis2_char_t* AXIS2_CALL |
| oxs_util_generate_nonce(const axutil_env_t *env, int length) |
| { |
| oxs_buffer_t *buffer = NULL; |
| axis2_status_t status = AXIS2_FAILURE; |
| char *rand_str = NULL; |
| axis2_char_t* encoded_str = NULL; |
| |
| buffer = oxs_buffer_create(env); |
| status = openssl_generate_random_data(env, buffer, length); |
| rand_str = (char*)oxs_buffer_get_data(buffer, env); |
| encoded_str = AXIS2_MALLOC(env->allocator, sizeof(char) * (axutil_base64_encode_len(length)+1)); |
| axutil_base64_encode(encoded_str, rand_str, oxs_buffer_get_size(buffer, env)); |
| oxs_buffer_free(buffer, env); |
| |
| return encoded_str; |
| } |
| |
| |
| |
| /* Generates an id for an element. |
| * Specially used in xml encryption and signature references. |
| * */ |
| AXIS2_EXTERN axis2_char_t* AXIS2_CALL |
| oxs_util_generate_id(const axutil_env_t *env, |
| axis2_char_t *prefix) |
| { |
| axis2_char_t *id = NULL; |
| char _id[50]; |
| axis2_char_t *random ; |
| axis2_char_t *uuid = NULL; |
| |
| uuid = axutil_uuid_gen(env); |
| random = axutil_strndup(env, uuid, 23); |
| sprintf(_id, "%s-%s", prefix, random); |
| id = (axis2_char_t*)axutil_strdup(env, _id); |
| AXIS2_FREE(env->allocator, uuid); |
| AXIS2_FREE(env->allocator, random); |
| random = NULL; |
| return id; |
| |
| } |
| |
| AXIS2_EXTERN oxs_key_mgr_format_t AXIS2_CALL |
| oxs_util_get_format_by_file_extension(const axutil_env_t *env, |
| axis2_char_t *file_name) |
| { |
| axis2_char_t *extension = NULL; |
| if(!file_name){ |
| return OXS_ASYM_CTX_FORMAT_UNKNOWN; |
| } |
| extension = axutil_rindex(file_name, '.'); |
| if(!extension){ |
| /*No extension*/ |
| /*Its safe to assume that PEM can be without extension*/ |
| return OXS_ASYM_CTX_FORMAT_PEM; |
| } |
| |
| if((strcmp(extension, ".pfx") == 0) || (strcmp(extension, ".p12") == 0) ){ |
| return OXS_ASYM_CTX_FORMAT_PKCS12; |
| }else{ |
| /*Its safe to assume that PEM can be in any extensions. e.g. .cert, .cer, .pem*/ |
| return OXS_ASYM_CTX_FORMAT_PEM; |
| } |
| |
| } |
| |
| AXIS2_EXTERN axis2_char_t *AXIS2_CALL |
| oxs_util_get_newline_removed_string(const axutil_env_t *env, |
| axis2_char_t *input) |
| { |
| /*axis2_char_t *output = NULL; |
| int i = 0; |
| |
| output = AXIS2_MALLOC(env->allocator, axutil_strlen(input) +1); |
| |
| while(*input!='\0') |
| { |
| if(*input!='\n') |
| { |
| output[i] = *input; |
| i++; |
| } |
| input++; |
| } |
| output[i]='\0'; |
| return output;*/ |
| |
| axis2_char_t *output = NULL; |
| int index = 0; |
| int len = axutil_strlen(input); |
| |
| output = AXIS2_MALLOC(env->allocator, len +1); |
| |
| while(len > 0) |
| { |
| size_t i = 0; |
| |
| /* scan buffer until the next newline character and skip it */ |
| axis2_char_t *pos = (axis2_char_t*)strchr(input, '\n'); |
| if(pos) |
| { |
| i = pos - input; |
| } |
| else |
| { |
| i = len; |
| } |
| |
| /* write everything until the special character */ |
| if(i > 0) |
| { |
| memcpy(output + index, input, i); |
| input += i; |
| index += i; |
| len -= i; |
| } |
| |
| /* skip the new line */ |
| if(len > 0) |
| { |
| ++input; |
| --len; |
| } |
| } |
| |
| output[index]='\0'; |
| return output; |
| } |