| /* |
| * 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 <axiom_mime_part.h> |
| #include <axiom_data_handler.h> |
| #include "axiom_mime_body_part.h" |
| #include <axutil_string.h> |
| #include <axiom_text.h> |
| #include <axiom_mime_const.h> |
| |
| |
| static axis2_status_t |
| axiom_mime_part_write_body_part_to_list( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axiom_mime_body_part_t *part, |
| axis2_char_t *boundary); |
| |
| static axis2_status_t |
| axiom_mime_part_write_mime_boundary( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axis2_char_t *boundary); |
| |
| static axis2_status_t |
| axiom_mime_part_finish_adding_parts( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axis2_char_t *boundary); |
| |
| /* This method will create a mime_part |
| * A mime part will encapsulate a buffer |
| * a file or a callback to load the attachment |
| which needs to be send */ |
| |
| 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; |
| } |
| } |
| |
| /* Frees the mime_part */ |
| |
| AXIS2_EXTERN void AXIS2_CALL |
| axiom_mime_part_free( |
| axiom_mime_part_t *mime_part, |
| const axutil_env_t *env) |
| { |
| if(mime_part) |
| { |
| if(mime_part->type == AXIOM_MIME_PART_BUFFER) |
| { |
| if(mime_part->part) |
| { |
| AXIS2_FREE(env->allocator, mime_part->part); |
| mime_part->part = NULL; |
| } |
| } |
| else if(mime_part->type == AXIOM_MIME_PART_FILE) |
| { |
| if(mime_part->file_name) |
| { |
| AXIS2_FREE(env->allocator, mime_part->file_name); |
| mime_part->file_name = NULL; |
| } |
| } |
| |
| AXIS2_FREE(env->allocator, mime_part); |
| mime_part = NULL; |
| } |
| return; |
| } |
| |
| /* This method will create a mime_boundary buffer |
| * and based on the buffer creates a mime_part. |
| * This will be added to the array_list so later in the trasnport |
| * this can be put to the wire. */ |
| |
| static axis2_status_t |
| axiom_mime_part_write_mime_boundary( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axis2_char_t *boundary) |
| { |
| axis2_byte_t *byte_buffer = NULL; |
| axis2_byte_t *byte_stream = NULL; |
| int size = 0; |
| axiom_mime_part_t *boundary_part = NULL; |
| |
| boundary_part = axiom_mime_part_create(env); |
| |
| byte_buffer = (axis2_byte_t *)boundary; |
| size = axutil_strlen(boundary); |
| |
| byte_stream = AXIS2_MALLOC(env->allocator, (size + 2) * sizeof(axis2_byte_t)); |
| if(!byte_stream) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create byte stream"); |
| return AXIS2_FAILURE; |
| } |
| |
| /* Mime boundary is always in the following form |
| --MimeBoundary */ |
| |
| byte_stream[0] = AXIOM_MIME_BOUNDARY_BYTE; |
| byte_stream[1] = AXIOM_MIME_BOUNDARY_BYTE; |
| |
| memcpy(byte_stream + 2, byte_buffer, size); |
| |
| boundary_part->part = byte_stream; |
| boundary_part->part_size = size + 2; |
| boundary_part->type = AXIOM_MIME_PART_BUFFER; |
| |
| axutil_array_list_add(list, env, boundary_part); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| /* This method will add the attachment file related information |
| to the list. It will create a mime_part from those information |
| and add to the list. If there are not data_handlers in the mime_body |
| then this method just add the headers. */ |
| |
| static axis2_status_t |
| axiom_mime_part_write_body_part_to_list( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axiom_mime_body_part_t *part, |
| axis2_char_t *boundary) |
| { |
| axiom_mime_part_t *crlf1 = NULL; |
| axiom_mime_part_t *crlf2 = NULL; |
| axis2_status_t status = AXIS2_SUCCESS; |
| |
| /* We are adding accoarding to the following format here. |
| * --MimeBoundary |
| * mime_header1 |
| * mime_header2 |
| * mime_header3 */ |
| |
| status = axiom_mime_part_write_mime_boundary(env, list, boundary); |
| |
| if(status != AXIS2_SUCCESS) |
| { |
| return status; |
| } |
| |
| /* Then we will add the new line charator after |
| * the mime_boundary */ |
| |
| crlf1 = axiom_mime_part_create(env); |
| |
| crlf1->part = (axis2_byte_t *)axutil_strdup(env, AXIS2_CRLF); |
| crlf1->part_size = 2; |
| crlf1->type = AXIOM_MIME_PART_BUFFER; |
| |
| axutil_array_list_add(list, env, crlf1); |
| |
| /*This method will fill the list with mime_headers and |
| *if there is an attachment with attachment details*/ |
| |
| axiom_mime_body_part_write_to_list(part, env, list); |
| |
| /* Then add the next \r\n after the attachment */ |
| |
| crlf2 = axiom_mime_part_create(env); |
| |
| crlf2->part = (axis2_byte_t *)axutil_strdup(env, AXIS2_CRLF); |
| crlf2->part_size = 2; |
| crlf2->type = AXIOM_MIME_PART_BUFFER; |
| |
| axutil_array_list_add(list, env, crlf2); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| /* This methos will add the final mime_boundary |
| * It is in --MimeBoundary-- format */ |
| |
| static axis2_status_t |
| axiom_mime_part_finish_adding_parts( |
| const axutil_env_t *env, |
| axutil_array_list_t *list, |
| axis2_char_t *boundary) |
| { |
| axis2_byte_t *byte_buffer = NULL; |
| axis2_byte_t *byte_stream = NULL; |
| int size = 0; |
| axiom_mime_part_t *final_part = NULL; |
| |
| size = axutil_strlen(boundary); |
| byte_buffer = (axis2_byte_t *)boundary; |
| |
| /* There is -- before and after so the length of the |
| * actual part is mime_boundary_len + 4 */ |
| |
| byte_stream = AXIS2_MALLOC(env->allocator, (size + 4) * sizeof(axis2_byte_t)); |
| if(!byte_stream) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create byte stream"); |
| return AXIS2_FAILURE; |
| } |
| |
| /* Adding the starting -- */ |
| |
| byte_stream[0] = AXIOM_MIME_BOUNDARY_BYTE; |
| byte_stream[1] = AXIOM_MIME_BOUNDARY_BYTE; |
| if(byte_buffer) |
| { |
| memcpy(byte_stream + 2, byte_buffer, size); |
| } |
| else |
| { |
| AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "Byte buffer not available for writing"); |
| } |
| |
| /* Adding the final -- */ |
| |
| byte_stream[size + 2] = AXIOM_MIME_BOUNDARY_BYTE; |
| byte_stream[size + 3] = AXIOM_MIME_BOUNDARY_BYTE; |
| |
| /* Now we add this as an mime_part to |
| * the list. */ |
| |
| final_part = axiom_mime_part_create(env); |
| |
| if(!final_part) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create final_part"); |
| return AXIS2_FAILURE; |
| } |
| |
| final_part->part = byte_stream; |
| final_part->part_size = size + 4; |
| final_part->type = AXIOM_MIME_PART_BUFFER; |
| |
| axutil_array_list_add(list, env, final_part); |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| /* This is the method which creates the content-type string |
| which is in the HTTP header or in mime_headers*/ |
| |
| AXIS2_EXTERN const axis2_char_t *AXIS2_CALL |
| axiom_mime_part_get_content_type_for_mime( |
| const axutil_env_t *env, |
| axis2_char_t *boundary, |
| axis2_char_t *content_id, |
| axis2_char_t *char_set_encoding, |
| const axis2_char_t *soap_content_type) |
| { |
| axis2_char_t *content_type_string = NULL; |
| axis2_char_t *temp_content_type_string = NULL; |
| |
| content_type_string = axutil_strdup(env, AXIOM_MIME_TYPE_MULTIPART_RELATED); |
| if(!content_type_string) |
| { |
| AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "Creation of Content-Type string failed"); |
| return NULL; |
| } |
| temp_content_type_string = axutil_stracat(env, content_type_string, "; "); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| if(boundary) |
| { |
| temp_content_type_string = |
| axutil_stracat(env, content_type_string, |
| AXIOM_MIME_HEADER_FIELD_BOUNDARY "="); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, boundary); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, "; "); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| } temp_content_type_string = |
| axutil_stracat(env, content_type_string, |
| AXIOM_MIME_HEADER_FIELD_TYPE "=\"" AXIOM_MIME_TYPE_XOP_XML "\""); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, "; "); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| if(content_id) |
| { |
| temp_content_type_string = |
| axutil_stracat(env, content_type_string, |
| AXIOM_MIME_HEADER_FIELD_START "=\"<"); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, content_id); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, ">\""); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, "; "); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| } |
| if(soap_content_type) |
| { |
| temp_content_type_string = |
| axutil_stracat(env, content_type_string, |
| AXIOM_MIME_HEADER_FIELD_START_INFO "=\""); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, soap_content_type); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, "\"; "); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| } |
| if(char_set_encoding) |
| { |
| temp_content_type_string = |
| axutil_stracat(env, content_type_string, |
| AXIOM_MIME_HEADER_FIELD_CHARSET "=\""); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, char_set_encoding); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| temp_content_type_string = axutil_stracat(env, content_type_string, "\""); |
| AXIS2_FREE(env->allocator, content_type_string); |
| content_type_string = temp_content_type_string; |
| } |
| |
| return content_type_string; |
| } |
| |
| /* This method is the core of attachment sending |
| * part. It will build each and every part and put them in |
| * an array_list. Instead of a big buffer we pass the array_list |
| * with small buffers and attachment locations. */ |
| |
| AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL |
| axiom_mime_part_create_part_list( |
| const axutil_env_t *env, |
| axis2_char_t *soap_body, |
| axutil_array_list_t *binary_node_list, |
| axis2_char_t *boundary, |
| axis2_char_t *content_id, |
| axis2_char_t *char_set_encoding, |
| const axis2_char_t *soap_content_type) |
| { |
| axis2_status_t status = AXIS2_FAILURE; |
| axis2_char_t *header_value = NULL; |
| axis2_char_t *temp_header_value = NULL; |
| axis2_char_t *content_id_string = NULL; |
| axis2_char_t *temp_content_id_string = NULL; |
| axiom_mime_body_part_t *root_mime_body_part = NULL; |
| axis2_char_t *soap_body_buffer = NULL; |
| axutil_array_list_t *part_list = NULL; |
| axiom_mime_part_t *soap_part = NULL; |
| |
| part_list = axutil_array_list_create(env, 0); |
| |
| if(!part_list) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot create part list array"); |
| return NULL; |
| } |
| |
| /* This mime_body part just keeps the mime_headers of the |
| * SOAP part. Since it is not created from an axiom_text |
| * this will not contain an attachment*/ |
| |
| root_mime_body_part = axiom_mime_body_part_create(env); |
| |
| if(!root_mime_body_part) |
| { |
| return NULL; |
| } |
| |
| /* In order to understand the following code which creates |
| * mime_headers go through the code with a sample mtom message */ |
| |
| /* Adding Content-Type Header */ |
| header_value = axutil_strdup(env, AXIOM_MIME_TYPE_XOP_XML |
| ";" AXIOM_MIME_HEADER_FIELD_CHARSET "="); |
| temp_header_value = axutil_stracat(env, header_value, char_set_encoding); |
| AXIS2_FREE(env->allocator, header_value); |
| header_value = temp_header_value; |
| temp_header_value = axutil_stracat(env, header_value, ";" |
| AXIOM_MIME_HEADER_FIELD_TYPE "=\""); |
| AXIS2_FREE(env->allocator, header_value); |
| header_value = temp_header_value; |
| temp_header_value = axutil_stracat(env, header_value, soap_content_type); |
| AXIS2_FREE(env->allocator, header_value); |
| header_value = temp_header_value; |
| temp_header_value = axutil_stracat(env, header_value, "\";"); |
| AXIS2_FREE(env->allocator, header_value); |
| header_value = temp_header_value; |
| axiom_mime_body_part_add_header(root_mime_body_part, env, AXIOM_MIME_HEADER_CONTENT_TYPE, |
| header_value); |
| |
| /* Adding Content Transfer Encoding header */ |
| |
| axiom_mime_body_part_add_header(root_mime_body_part, env, |
| AXIOM_MIME_HEADER_CONTENT_TRANSFER_ENCODING, axutil_strdup(env, |
| AXIOM_MIME_CONTENT_TRANSFER_ENCODING_BINARY)); |
| |
| /* Adding Content ID header */ |
| |
| content_id_string = (axis2_char_t *)"<"; |
| content_id_string = axutil_stracat(env, content_id_string, content_id); |
| temp_content_id_string = axutil_stracat(env, content_id_string, ">"); |
| AXIS2_FREE(env->allocator, content_id_string); |
| content_id_string = temp_content_id_string; |
| axiom_mime_body_part_add_header(root_mime_body_part, env, AXIOM_MIME_HEADER_CONTENT_ID, |
| content_id_string); |
| |
| /* Now first insert the headers needed for SOAP */ |
| |
| /* After calling this method we have mime_headers of the SOAP envelope |
| * as a mime_part in the array_list */ |
| |
| status = axiom_mime_part_write_body_part_to_list(env, part_list, root_mime_body_part, boundary); |
| |
| if(status == AXIS2_FAILURE) |
| { |
| return NULL; |
| } |
| |
| /* Now add the SOAP body */ |
| |
| axiom_mime_body_part_free(root_mime_body_part, env); |
| root_mime_body_part = NULL; |
| |
| soap_part = axiom_mime_part_create(env); |
| |
| if(!soap_part) |
| { |
| return NULL; |
| } |
| |
| /* The atachment's mime_boundary will start after a new line charator */ |
| |
| soap_body_buffer = axutil_stracat(env, soap_body, AXIS2_CRLF); |
| |
| soap_part->part = (axis2_byte_t *)soap_body_buffer; |
| soap_part->part_size = (int)axutil_strlen(soap_body_buffer); |
| soap_part->type = AXIOM_MIME_PART_BUFFER; |
| |
| axutil_array_list_add(part_list, env, soap_part); |
| |
| /* Now we need to add each binary attachment to the array_list */ |
| |
| if(binary_node_list) |
| { |
| int j = 0; |
| for(j = 0; j < axutil_array_list_size(binary_node_list, env); j++) |
| { |
| /* Getting each attachment text node from the node list */ |
| |
| axiom_text_t *text = (axiom_text_t *)axutil_array_list_get(binary_node_list, env, j); |
| if(text) |
| { |
| axiom_mime_body_part_t *mime_body_part = NULL; |
| mime_body_part = axiom_mime_body_part_create_from_om_text(env, text); |
| |
| /* Let's fill the mime_part arraylist with attachment data*/ |
| if(!mime_body_part) |
| { |
| return NULL; |
| } |
| |
| /* This call will create mime_headers for the attachment and put |
| * them to the array_list. Then put the attachment file_name to the |
| * list */ |
| |
| status = axiom_mime_part_write_body_part_to_list(env, part_list, mime_body_part, |
| boundary); |
| |
| if(status == AXIS2_FAILURE) |
| { |
| return NULL; |
| } |
| |
| axiom_mime_body_part_free(mime_body_part, env); |
| mime_body_part = NULL; |
| } |
| } |
| } |
| |
| /* Now we have the SOAP message, all the attachments and headers are added to the list. |
| * So let's add the final mime_boundary with -- at the end */ |
| |
| status = axiom_mime_part_finish_adding_parts(env, part_list, boundary); |
| if(status == AXIS2_FAILURE) |
| { |
| return NULL; |
| } |
| return part_list; |
| } |
| |
