| /* |
| * 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 <axutil_utils.h> |
| #include <axutil_error.h> |
| #include <axutil_string.h> |
| #include <axutil_network_handler.h> |
| #include <axutil_stream.h> |
| #include <time.h> |
| |
| #include "tcpmon_entry_local.h" |
| #include "tcpmon_session_local.h" |
| |
| #define AXIS2_TCPMON |
| /** |
| * @brief |
| */ |
| typedef struct tcpmon_entry_impl |
| { |
| tcpmon_entry_t entry; |
| |
| axis2_char_t* arrived_time; |
| axis2_char_t* sent_time; |
| axis2_char_t* sent_data; |
| axis2_char_t* arrived_data; |
| axis2_char_t* sent_headers; |
| axis2_char_t* arrived_headers; |
| axis2_bool_t is_success; |
| axis2_char_t* time_diff; |
| axis2_char_t* test_file_name; |
| int format_bit; |
| } |
| tcpmon_entry_impl_t; |
| |
| #define AXIS2_INTF_TO_IMPL(entry) \ |
| ((tcpmon_entry_impl_t *) entry) |
| |
| /************************* Function prototypes ********************************/ |
| |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_free(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_time( tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_time(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_time_diff(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_data(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_headers(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_data(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_headers(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| |
| axis2_bool_t AXIS2_CALL |
| tcpmon_entry_is_success(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| |
| axis2_char_t* |
| get_current_stream_to_buffer(axutil_stream_t* stream, |
| const axutil_env_t* env, |
| int* stream_size); |
| |
| axis2_char_t* |
| read_current_stream(axutil_stream_t *stream, |
| const axutil_env_t *env, |
| int *stream_size, |
| axis2_char_t** header, |
| axis2_char_t** data); |
| |
| int |
| write_to_file (char *filename, |
| char *buffer); |
| |
| int AXIS2_CALL |
| tcpmon_entry_get_format_bit(tcpmon_entry_t *entry, |
| const axutil_env_t *env); |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_set_format_bit(tcpmon_entry_t *entry, |
| const axutil_env_t *env, |
| int format_bit); |
| /************************** End of function prototypes ************************/ |
| |
| tcpmon_entry_t * AXIS2_CALL |
| tcpmon_entry_create(const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = (tcpmon_entry_impl_t *) AXIS2_MALLOC(env-> |
| allocator, sizeof(tcpmon_entry_impl_t)); |
| |
| if (! entry_impl) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| entry_impl -> arrived_time = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl -> sent_time = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl -> time_diff = AXIS2_MALLOC(env->allocator, 32); |
| entry_impl -> arrived_data = NULL; |
| entry_impl -> sent_data = NULL; |
| entry_impl -> arrived_headers = NULL; |
| entry_impl -> sent_headers = NULL; |
| entry_impl -> is_success = AXIS2_FALSE; |
| entry_impl -> format_bit = 0; |
| |
| entry_impl->entry.ops = |
| AXIS2_MALLOC(env->allocator, sizeof(tcpmon_entry_ops_t)); |
| if (! entry_impl->entry.ops) |
| { |
| tcpmon_entry_free(&(entry_impl->entry), env); |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| return NULL; |
| } |
| |
| entry_impl->entry.ops->free = tcpmon_entry_free; |
| entry_impl->entry.ops->arrived_time = tcpmon_entry_arrived_time; |
| entry_impl->entry.ops->sent_time = tcpmon_entry_sent_time; |
| entry_impl->entry.ops->time_diff = tcpmon_entry_time_diff; |
| entry_impl->entry.ops->sent_data = tcpmon_entry_sent_data; |
| entry_impl->entry.ops->sent_headers = tcpmon_entry_sent_headers; |
| entry_impl->entry.ops->arrived_data = tcpmon_entry_arrived_data; |
| entry_impl->entry.ops->arrived_headers = tcpmon_entry_arrived_headers; |
| entry_impl->entry.ops->is_success = tcpmon_entry_is_success; |
| entry_impl->entry.ops->set_format_bit = tcpmon_entry_set_format_bit; |
| entry_impl->entry.ops->get_format_bit = tcpmon_entry_get_format_bit; |
| |
| return &(entry_impl->entry); |
| } |
| |
| |
| /***************************Function implementation****************************/ |
| |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_free(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| if (entry->ops) |
| { |
| AXIS2_FREE(env->allocator, entry->ops); |
| entry->ops = NULL; |
| } |
| |
| if (entry_impl -> arrived_time) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> arrived_time); |
| entry_impl -> arrived_time = NULL; |
| } |
| if (entry_impl -> sent_time) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> sent_time); |
| entry_impl -> sent_time = NULL; |
| } |
| if (entry_impl -> time_diff) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> time_diff); |
| entry_impl -> time_diff = NULL; |
| } |
| if (entry_impl -> arrived_data) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> arrived_data); |
| entry_impl -> arrived_data = NULL; |
| } |
| if (entry_impl -> sent_data) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> sent_data); |
| entry_impl -> sent_data = NULL; |
| } |
| if (entry_impl -> arrived_headers) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> arrived_headers); |
| entry_impl -> arrived_headers = NULL; |
| } |
| if (entry_impl -> sent_headers) |
| { |
| AXIS2_FREE(env-> allocator, entry_impl -> sent_headers); |
| entry_impl -> sent_headers = NULL; |
| } |
| |
| if (entry_impl) |
| { |
| AXIS2_FREE(env->allocator, entry_impl); |
| entry_impl = NULL; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_time(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> arrived_time; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_time(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> sent_time; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_time_diff(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> time_diff; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_data(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> sent_data; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_sent_headers(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> sent_headers; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_data(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> arrived_data; |
| } |
| |
| axis2_char_t* AXIS2_CALL |
| tcpmon_entry_arrived_headers(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> arrived_headers; |
| } |
| |
| axis2_bool_t AXIS2_CALL |
| tcpmon_entry_is_success(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl-> is_success; |
| } |
| |
| int AXIS2_CALL |
| tcpmon_entry_get_format_bit(tcpmon_entry_t *entry, |
| const axutil_env_t *env) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK (env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| return entry_impl->format_bit; |
| } |
| |
| axis2_status_t AXIS2_CALL |
| tcpmon_entry_set_format_bit(tcpmon_entry_t *entry, |
| const axutil_env_t *env, |
| int format_bit) |
| { |
| tcpmon_entry_impl_t *entry_impl = NULL; |
| |
| AXIS2_ENV_CHECK (env, AXIS2_FAILURE); |
| |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| entry_impl->format_bit = format_bit; |
| |
| return AXIS2_SUCCESS; |
| } |
| /** implimentations for protected methods */ |
| |
| /** executes as new entry arises */ |
| void* AXIS2_CALL tcpmon_entry_new_entry_funct(axutil_thread_t *thd, void* data) |
| { |
| tcpmon_entry_request_data_t* req_data = data; |
| const axutil_env_t* env = NULL; |
| int client_socket = -1; |
| int host_socket = -1; |
| tcpmon_session_t* session; |
| TCPMON_SESSION_TRANS_ERROR_FUNCT on_trans_fault_funct; |
| TCPMON_SESSION_NEW_ENTRY_FUNCT on_new_entry; |
| |
| axutil_stream_t* client_stream = NULL; |
| axutil_stream_t* host_stream = NULL; |
| int buffer_size = 0; |
| axis2_char_t* headers = NULL; |
| axis2_char_t* content = NULL; |
| axis2_char_t* buffer = NULL; |
| time_t now; |
| struct tm* localTime = NULL; |
| int arrived_secs = 0; |
| int sent_secs = 0; |
| int time_diff_i = 0; |
| int target_port = 0; |
| axis2_char_t* target_host = NULL; |
| int test_bit = 0; |
| int format_bit = 0; |
| tcpmon_entry_t* entry = NULL; |
| tcpmon_entry_impl_t* entry_impl = NULL; |
| |
| env = req_data -> env; |
| client_socket = req_data-> socket; |
| session = req_data-> session; |
| on_trans_fault_funct = |
| tcpmon_session_get_on_trans_fault(session, env); |
| on_new_entry = |
| tcpmon_session_get_on_new_entry(session, env); |
| |
| |
| |
| entry = tcpmon_entry_create(env); |
| entry_impl = AXIS2_INTF_TO_IMPL(entry); |
| |
| target_port = TCPMON_SESSION_GET_TARGET_PORT(session, env); |
| target_host = TCPMON_SESSION_GET_TARGET_HOST(session, env); |
| |
| if (target_port == -1 || target_host == NULL) |
| { |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Missing target port and host" |
| "input missing"); |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct)(env, |
| "Missing target port and host"); |
| } |
| return NULL; |
| } |
| client_stream = axutil_stream_create_socket(env, client_socket); |
| if (! client_stream) |
| { |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating client stream" |
| "handling response"); |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct)(env, |
| "error in creating the client stream"); |
| } |
| return NULL; |
| } |
| |
| |
| buffer = read_current_stream(client_stream, env, &buffer_size, |
| &headers, &content); |
| |
| test_bit = TCPMON_SESSION_GET_TEST_BIT(session, env); |
| |
| if (test_bit) |
| { |
| write_to_file ("reqest", buffer); |
| } |
| |
| format_bit = TCPMON_SESSION_GET_FORMAT_BIT(session, env); |
| TCPMON_ENTRY_SET_FORMAT_BIT(entry, env, format_bit); |
| |
| |
| now = time(NULL); |
| localTime = localtime(&now); |
| |
| sprintf(entry_impl-> sent_time, "%d:%d:%d" , localTime-> tm_hour, localTime-> tm_min, |
| localTime-> tm_sec); |
| sent_secs = localTime-> tm_hour * 60 * 60 + |
| localTime-> tm_min * 60 + |
| localTime-> tm_sec; |
| |
| /*free ( localTime); */ |
| |
| entry_impl-> sent_headers = headers; |
| entry_impl-> sent_data = content; |
| |
| if (on_new_entry) |
| { |
| (on_new_entry)(env, entry, 0); |
| } |
| |
| |
| |
| host_socket = axutil_network_handler_open_socket(env, target_host, target_port); |
| if (-1 == host_socket) |
| { |
| axutil_stream_write(client_stream, env, NULL, 0); |
| axutil_stream_free(client_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host_socket" |
| "creating socket"); |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct)(env, |
| "error in creating the host socket"); |
| } |
| return NULL; |
| } |
| |
| host_stream = axutil_stream_create_socket(env, host_socket); |
| if (! host_stream) |
| { |
| axutil_stream_write(client_stream, env, NULL, 0); |
| axutil_stream_free(client_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| axutil_network_handler_close_socket(env, host_socket); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error in creating host stream" |
| "handling response"); |
| /** call the callback */ |
| if (on_trans_fault_funct) |
| { |
| (on_trans_fault_funct)(env, |
| "error in creating the host stream"); |
| } |
| return NULL; |
| } |
| |
| axutil_stream_write(host_stream, env, buffer , buffer_size); |
| AXIS2_FREE(env-> allocator, buffer); |
| |
| buffer = read_current_stream(host_stream, env, &buffer_size, |
| &headers, &content); |
| |
| test_bit = TCPMON_SESSION_GET_TEST_BIT (session, env); |
| if (test_bit) |
| { |
| write_to_file ("response", buffer); |
| } |
| |
| now = time(NULL); |
| localTime = localtime(&now); |
| |
| sprintf(entry_impl-> arrived_time, "%d:%d:%d" , localTime-> tm_hour, localTime-> tm_min, |
| localTime-> tm_sec); |
| arrived_secs = localTime-> tm_hour * 60 * 60 + |
| localTime-> tm_min * 60 + |
| localTime-> tm_sec; |
| /*free ( localTime); */ |
| |
| |
| time_diff_i = arrived_secs - sent_secs; |
| if (time_diff_i < 0) |
| { |
| time_diff_i += 24 * 60 * 60 ; |
| } |
| sprintf(entry_impl-> time_diff, "%d sec(s)", time_diff_i); |
| |
| entry_impl-> arrived_headers = headers; |
| entry_impl-> arrived_data = content; |
| if (buffer == NULL || buffer_size == 0) |
| { |
| entry_impl->is_success = 0; |
| } |
| else |
| { |
| entry_impl->is_success = 1; |
| } |
| |
| if (on_new_entry) |
| { |
| (on_new_entry)(env, entry, 1); |
| } |
| |
| |
| axutil_stream_write(client_stream, env, buffer, buffer_size); |
| AXIS2_FREE(env-> allocator, buffer); |
| |
| axutil_stream_free(client_stream, env); |
| axutil_stream_free(host_stream, env); |
| axutil_network_handler_close_socket(env, client_socket); |
| axutil_network_handler_close_socket(env, host_socket); |
| |
| return NULL; |
| } |
| |
| |
| axis2_char_t* |
| read_current_stream(axutil_stream_t *stream, |
| const axutil_env_t *env, |
| int *stream_size, |
| axis2_char_t **header, |
| axis2_char_t **data) |
| { |
| int read_size = 0; |
| axis2_char_t *buffer = NULL; |
| axis2_char_t *header_ptr = NULL; |
| axis2_char_t *body_ptr = NULL; |
| int header_found = 0; |
| int header_just_finished = 0; |
| int read = 0; |
| int header_width = 0; |
| int current_line_offset = 0; |
| axis2_char_t *current_line = NULL; |
| int line_just_ended = 1; |
| axis2_char_t *length_char = 0; |
| int length = -1; |
| int chunked_encoded = 0; |
| |
| |
| buffer = AXIS2_MALLOC(env-> allocator, sizeof(axis2_char_t)); |
| do |
| { |
| buffer = AXIS2_REALLOC(env-> allocator, buffer, |
| sizeof(axis2_char_t) * (read_size + 1)); |
| read = axutil_stream_read(stream, env , buffer + read_size, 1); |
| |
| if (header_just_finished) |
| { |
| header_just_finished = 0; |
| header_width = read_size; |
| } |
| /** identify the content lenth*/ |
| if (!header_found && *(buffer + read_size) == '\r') |
| { |
| *(buffer + read_size) = '\0'; |
| current_line = buffer + current_line_offset; |
| if (strstr(current_line, "Content-Length")) |
| { |
| if ((length_char = strstr(current_line, ":"))) |
| { |
| length_char++; |
| length = atoi(length_char); |
| } |
| } |
| *(buffer + read_size) = '\r'; |
| } |
| if (!header_found && line_just_ended) |
| { |
| line_just_ended = 0; |
| current_line_offset = read_size; |
| } |
| if (!header_found && *(buffer + read_size) == '\n') |
| { |
| line_just_ended = 1; /* set for the next loop to read*/ |
| } |
| if (header_found) |
| { |
| length--; |
| } |
| if (header_found && |
| read_size >= 4 && |
| chunked_encoded == 1 && |
| *(buffer + read_size) == '\n' && |
| *(buffer + read_size - 1) == '\r' && |
| *(buffer + read_size - 2) == '\n' && |
| *(buffer + read_size - 3) == '\r' && |
| *(buffer + read_size - 4) == '0') |
| { |
| length = 0; /** this occurs in chunked transfer encoding */ |
| } |
| |
| /** identify the end of the header */ |
| if (!header_found && |
| read_size >= 3 && |
| *(buffer + read_size) == '\n' && |
| *(buffer + read_size - 1) == '\r' && |
| *(buffer + read_size - 2) == '\n' && |
| *(buffer + read_size - 3) == '\r') |
| { |
| header_found = 1; |
| *(buffer + read_size - 3) = '\0'; |
| header_ptr = (axis2_char_t*)axutil_strdup(env, buffer); |
| header_just_finished = 1; |
| *(buffer + read_size - 3) = '\r'; |
| } |
| read_size ++; |
| if (!chunked_encoded && length < -1) |
| { |
| header_width = 0; |
| /* break;*/ |
| /** this is considered as transfer-encoding = chunked */ |
| chunked_encoded = 1; |
| header_found = 1; |
| *(buffer + read_size - 3) = '\0'; |
| header_ptr = (axis2_char_t*)axutil_strdup(env, buffer); |
| header_just_finished = 1; |
| *(buffer + read_size - 3) = '\r'; |
| } |
| } |
| while (length != 0); |
| |
| if (header_width != 0) |
| { |
| body_ptr = buffer + header_width; |
| *data = (axis2_char_t*) axutil_strdup(env, body_ptr); |
| } |
| else |
| { |
| *(buffer + read_size) = '\0'; |
| header_ptr = (axis2_char_t*)axutil_strdup(env, buffer); |
| /** soap body part is unavailable */ |
| *data = NULL; |
| } |
| |
| *header = header_ptr; |
| *stream_size = read_size; |
| return buffer; |
| } |
| |
| |
| |
| |
| int |
| write_to_file (char *filename, |
| char *buffer) |
| { |
| int size = 0; |
| if (filename) |
| { |
| |
| FILE *fp = fopen (filename, "a+"); |
| size = fwrite (buffer, 1, strlen (buffer), fp); |
| fclose (fp); |
| } |
| return size; |
| } |
| |
| |
| |
| |
| |
| |
| |