axis2_char_t* AXIS2_CALL get_ht_password(rampart_callback_t *rcb, const axutil_env_t *env, const axis2_char_t *username, void *param) { axis2_char_t * password = NULL; FILE *file = NULL; /*The default location is the following. But this will be overridden by the property values set in the msg_ctx*/ axis2_char_t *filename = "/usr/local/apache2/passwd/passwords"; if(param){ filename = (axis2_char_t *)param; }else{ AXIS2_LOG_INFO(env->log, "Using the default password file location %s", filename); } file = fopen ( filename, "r" ); if ( file != NULL ) { axis2_char_t line [ 128 ]; axis2_char_t ch = 0; axis2_char_t *res = NULL; axis2_char_t *un = NULL; axis2_char_t *pw = NULL; while ( fgets ( line, sizeof line, file ) != NULL ) { res = axutil_strstr(line, ":"); ch = res[0]; res[0] = '\0'; un = (axis2_char_t *) axutil_strdup(env, line); res[0] = ch; if(0 == axutil_strcmp(un, username)){ pw = (axis2_char_t *) axutil_strdup( env, &(res[1])); password = axutil_strndup(env, pw, axutil_strlen(pw)-1); /*We need to remove the end of line character*/ break; } } AXIS2_FREE(env->allocator, un); AXIS2_FREE(env->allocator, pw); fclose ( file ); }else { AXIS2_LOG_INFO(env->log, "Cannot load the password file %s in the callback module", filename); perror ( filename ); } return password; };
axis2_char_t * wsclient_get_password (const axutil_env_t *env, const axis2_char_t *username, axis2_char_t *password_file_name) { axis2_char_t *filename = NULL; axis2_char_t * password = NULL; FILE *file = NULL; if(password_file_name) { filename = password_file_name; }else { AXIS2_LOG_INFO(env->log, "Using the default password file location %s", filename); } file = fopen ( filename, "r" ); if ( file != NULL ) { axis2_char_t line [ 128 ]; axis2_char_t ch = 0; axis2_char_t *res = NULL; axis2_char_t *un = NULL; axis2_char_t *pw = NULL; while ( fgets ( line, sizeof line, file ) != NULL ) { res = axutil_strstr(line, ":"); ch = res[0]; res[0] = '\0'; un = (axis2_char_t *) axutil_strdup(env, line); res[0] = ch; if(0 == axutil_strcmp(un, username)){ pw = (axis2_char_t *) axutil_strdup(env, &(res[1])); password = axutil_strndup(env, pw, axutil_strlen(pw)-1); break; } } AXIS2_FREE(env->allocator, un); AXIS2_FREE(env->allocator, pw); fclose ( file ); }else { AXIS2_LOG_INFO(env->log, "Cannot load the password file %s in the callback module", filename); perror ( filename ); } return password; }
static axis2_char_t* remote_registry_rest_client_extract_etag_info(const axutil_env_t *env, axis2_char_t *buffer) { axis2_char_t *etag_value = NULL; etag_value = axutil_strstr(buffer, REMOTE_REGISTRY_ETAG_HADER_KEY); if(etag_value) { axis2_char_t *c; /* get until the etag start */ etag_value += sizeof(REMOTE_REGISTRY_ETAG_HADER_KEY) -1; /* find the line end */ for(c = etag_value; *c != '\0' && *c != '\r'; c ++); *c = '\0'; etag_value = axutil_strdup(env, etag_value); } return etag_value; }
AXIS2_EXTERN axis2_char_t *AXIS2_CALL axutil_dll_desc_create_platform_specific_dll_name( axutil_dll_desc_t *dll_desc, const axutil_env_t *env, const axis2_char_t *class_name) { axis2_char_t *temp_name = NULL; AXIS2_ENV_CHECK(env, NULL); /* allow config to give a literal lib name since it may want a * versioned lib like "libfoo.so.0" */ if (axutil_strstr(class_name, AXIS2_LIB_SUFFIX)) { /* assume the class_name is the literal lib file name */ dll_desc->dll_name = axutil_strdup(env,class_name); return dll_desc->dll_name; } temp_name = axutil_stracat(env, AXIS2_LIB_PREFIX, class_name); dll_desc->dll_name = axutil_stracat(env, temp_name, AXIS2_LIB_SUFFIX); AXIS2_FREE(env->allocator, temp_name); return dll_desc->dll_name; }
int main() { int sock, bytes_recieved; char recv_data[10024]; struct hostent *host; struct sockaddr_in server_addr; const axis2_char_t *header = NULL; axis2_char_t *header_value = NULL; char *type3_header = NULL; char *type1_header = NULL; const char *user = "******", *domain = "mydomain", *password = "******", *workstation = "workstation"; axis2_status_t status = AXIS2_FAILURE; const axutil_env_t *env = NULL; env = axutil_env_create_all("mock_client.log", AXIS2_LOG_LEVEL_TRACE); host = gethostbyname(hostname); if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("Socket"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(port); server_addr.sin_addr = *((struct in_addr *)host->h_addr); bzero(&(server_addr.sin_zero),8); /* Create a normal message */ char *init_send = axutil_strdup(env, "HEAD /myservice/Service1.asmx HTTP/1.1\n"\ "Host: 172.16.176.132:8080\n"\ "User-Agent: Axis2C/1.7.0\n\n"); if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) { perror("Connect"); exit(1); } /* Send a normal message */ send(sock, init_send, strlen(init_send), 0); while(1) { bytes_recieved=recv(sock,recv_data,10024,0); recv_data[bytes_recieved] = '\0'; header = axutil_strstr(recv_data, "WWW-Authenticate: NTLM "); /* Process the challange */ if(header) { int i = 22; while(header[i] && isspace((unsigned char) header[i])) { i++; } if (header[i] != '\0') { int len = axutil_strlen(&header[i]); if (len == 0) { printf("invalid Negotiate token\n"); } else { header_value = axutil_strdup(env, &header[i]); } } if(header_value) { axis2_char_t *temp = strstr(header_value, "=="); temp = temp + 3; *temp = '\0'; header_value = axutil_strdup(env, header_value); } } if(!header_value) /* printf("unauth_header:\n%s\n", unauth_header); */ { axis2_char_t *encoded = NULL; int elen = 0; int flags = 0; axis2_ntlm_t *ntlm = NULL; ntlm = axis2_ntlm_create(env); status = axis2_ntlm_auth_create_type1_message(ntlm, env, &encoded, &elen, user, password, flags, domain); if(AXIS2_SUCCESS != status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_ntlm_auth_create_type1_message call failed"); printf("axis2_ntlm_auth_create_type1_message call failed\n"); return 1; } /* Ceate type 1(negotiation) header message from the recieved header */ type1_header = create_type1_header(env, encoded); /* Send netotiation message */ send(sock, type1_header,strlen(type1_header), 0); printf("sent:\n%s\n", type1_header); free(type1_header); continue; } if(header_value) { /*printf("header_value:\n***%s***\n", header_value);*/ int elen = 0; axis2_char_t *encoded = NULL; axis2_char_t *header_value = NULL; axis2_ntlm_t *ntlm = NULL; ntlm = axis2_ntlm_create(env); status = axis2_ntlm_auth_create_type3_message(ntlm, env, header_value, &encoded, &elen, user, password, domain, workstation); if(AXIS2_SUCCESS != status) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "axis2_ntlm_auth_create_type3_message call failed"); printf("axis2_ntlm_auth_create_type3_message call failed\n"); return 1; } /* Create Type3 (authentication) header */ type3_header = create_type3_header(env, encoded); break; } } /* Send Type3(authentication) message */ send(sock, type3_header, strlen(type3_header), 0); bytes_recieved=recv(sock,recv_data,10024,0); recv_data[bytes_recieved] = '\0'; printf("\nRecieved data:\n%s \n" , recv_data); close(sock); return 0; }
void wsf_util_pack_attachments ( axutil_env_t *env, axiom_node_t *node, VALUE attach_ht, int enable_mtom, char *default_cnt_type) { axiom_element_t *node_element = NULL; axiom_element_t *child_element = NULL; axiom_child_element_iterator_t *child_element_ite = NULL; axiom_node_t *child_node = NULL; int attachment_done = 0; axis2_char_t *element_localname = NULL; axiom_namespace_t *element_namespace = NULL; axis2_char_t *namespace_uri = NULL; if (!node) return; if (axiom_node_get_node_type(node, env) == AXIOM_ELEMENT) { node_element = axiom_node_get_data_element(node, env); if (node_element) { child_element_ite = axiom_element_get_child_elements(node_element, env, node); if (child_element_ite) { child_node = axiom_child_element_iterator_next(child_element_ite, env); attachment_done = 0; while (child_node && !attachment_done) { child_element = axiom_node_get_data_element(child_node, env); element_localname = axiom_element_get_localname(child_element, env); if (element_localname && (axutil_strcmp(element_localname, AXIS2_ELEMENT_LN_INCLUDE) == 0)) { element_namespace = axiom_element_get_namespace(child_element, env, child_node); if (element_namespace) { namespace_uri = axiom_namespace_get_uri(element_namespace, env); if (namespace_uri && (axutil_strcmp(namespace_uri, AXIS2_NAMESPACE_URI_INCLUDE) == 0)) { axis2_char_t *cnt_type = NULL; axis2_char_t *content_type = NULL; axis2_char_t *href = NULL; axis2_char_t* pos = NULL; cnt_type = axiom_element_get_attribute_value_by_name(node_element, env, AXIS2_ELEMENT_ATTR_NAME_CONTENT_TYPE); content_type = !cnt_type ? default_cnt_type : cnt_type; href = axiom_element_get_attribute_value_by_name(child_element, env, AXIS2_ELEMENT_ATTR_NAME_HREF); if ((axutil_strlen(href) > 4) && (pos = axutil_strstr (href, "cid:"))) { axis2_char_t* cid = NULL; VALUE content_tmp; void* content = NULL; unsigned int content_length = 0; cid = href + 4; content_tmp = rb_hash_aref(attach_ht, rb_str_new2(cid)); content_length = RSTRING(content_tmp)->len; content = malloc(sizeof (char) * content_length); memcpy (content, (const void*)STR2CSTR(content_tmp), content_length); if (content) { void *data_buffer = NULL; axiom_data_handler_t *data_handler = NULL; axiom_node_t *text_node = NULL; axiom_text_t *text = NULL; data_buffer = AXIS2_MALLOC (env->allocator, sizeof (char) * content_length); if (data_buffer) { memcpy (data_buffer, content, content_length); data_handler = axiom_data_handler_create (env, NULL, content_type); if (data_handler) { axiom_data_handler_set_binary_data (data_handler, env, (axis2_byte_t *)content, content_length); text = axiom_text_create_with_data_handler (env, node, data_handler, &text_node); if (enable_mtom == AXIS2_FALSE) axiom_text_set_optimize (text, env, AXIS2_FALSE); axiom_node_detach (child_node, env); } } attachment_done = 1; } } } } } child_node = axiom_child_element_iterator_next(child_element_ite, env); } } } } // Process child nodes child_node = axiom_node_get_first_child(node, env); while (child_node) { wsf_util_pack_attachments(env, child_node, attach_ht, enable_mtom, default_cnt_type); child_node = axiom_node_get_next_sibling(child_node, env); } }
AXIS2_EXTERN axis2_op_t *AXIS2_CALL axis2_svc_get_op_with_qname( const axis2_svc_t * svc, const axutil_env_t * env, const axutil_qname_t * op_qname) { axis2_op_t *op = NULL; axis2_char_t *nc_name = NULL; axis2_char_t *nc_tmp = NULL; /* This is just for the sake of comparison, * and must not be used to change the passed value */ axis2_bool_t is_matched = AXIS2_FALSE; AXIS2_PARAM_CHECK(env->error, op_qname, NULL); nc_name = axutil_qname_get_localpart(op_qname, env); nc_tmp = nc_name; op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING); if(op) { return op; } op = axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING); if(op) { return op; } if(*nc_tmp && svc->op_action_map) { axutil_hash_index_t *hi = NULL; const void *key = NULL; for(hi = axutil_hash_first(svc->op_action_map, env); hi; hi = axutil_hash_next(env, hi)) { axutil_hash_this(hi, &key, NULL, NULL); nc_tmp = nc_name; if(key) { axis2_char_t *search = NULL; axis2_bool_t match_start = AXIS2_TRUE; axis2_char_t *search_tmp = NULL; search = (axis2_char_t *)key; if(!axutil_strchr(search, '*')) { if(axutil_strstr(nc_tmp, search)) { axis2_char_t *comp_tmp = NULL; comp_tmp = axutil_strstr(nc_tmp, search); if(strlen(comp_tmp) == strlen(search)) { nc_tmp = (axis2_char_t *)key; is_matched = AXIS2_TRUE; break; } } continue; } if(search[0] == '*') { search++; if(!*search) { nc_tmp = (axis2_char_t *)key; is_matched = AXIS2_TRUE; break; } else if(axutil_strchr(search, '*')) { continue; } match_start = AXIS2_FALSE; } while(search && *search) { size_t length = 0; axis2_char_t *loc_tmp = NULL; if(search_tmp) { AXIS2_FREE(env->allocator, search_tmp); search_tmp = NULL; } loc_tmp = axutil_strchr(search, '*'); if(loc_tmp && *loc_tmp) { if(!loc_tmp[1]) { is_matched = AXIS2_TRUE; break; } length = (size_t)(loc_tmp - search); /* We are sure that the difference lies within the int range */ search_tmp = (axis2_char_t *)(AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * (length + 1))); strncpy(search_tmp, search, length); search_tmp[length] = '\0'; } else if(axutil_strstr(nc_tmp, search)) { axis2_char_t *comp_tmp = NULL; comp_tmp = axutil_strstr(nc_tmp, search); if(strlen(comp_tmp) == strlen(search)) { nc_tmp = (axis2_char_t *)key; is_matched = AXIS2_TRUE; break; } break; } else { break; } if(search_tmp && axutil_strstr(nc_tmp, search_tmp)) { if(match_start && !(axutil_strncmp(nc_tmp, search, (int)length) == 0)) { break; } else if(!match_start) { match_start = AXIS2_TRUE; } } else { break; } search += axutil_strlen(search_tmp) + 1; nc_tmp = axutil_strstr(nc_tmp, search_tmp) + axutil_strlen(search_tmp); } if(search_tmp) { AXIS2_FREE(env->allocator, search_tmp); search_tmp = NULL; } if(is_matched || !search || !*search) { nc_tmp = (axis2_char_t *)key; is_matched = AXIS2_TRUE; break; } } } } if(!is_matched) { nc_tmp = nc_name; } op = axutil_hash_get(svc->op_alias_map, nc_tmp, AXIS2_HASH_KEY_STRING); if(op) { return op; } return (axis2_op_t *)axutil_hash_get(svc->op_action_map, nc_tmp, AXIS2_HASH_KEY_STRING); }
AXIS2_EXTERN axis2_http_request_line_t *AXIS2_CALL axis2_http_request_line_parse_line( const axutil_env_t * env, const axis2_char_t * str) { axis2_char_t *req_line = NULL; axis2_char_t *method = NULL; axis2_char_t *uri = NULL; axis2_char_t *http_version = NULL; axis2_http_request_line_t *ret = NULL; axis2_char_t *tmp = NULL; int i = 0; AXIS2_PARAM_CHECK(env->error, str, NULL); tmp = axutil_strstr(str, AXIS2_HTTP_CRLF); if (!tmp) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); return NULL; } i = (int)(tmp - str); /* We are sure that the difference lies within the int range */ req_line = AXIS2_MALLOC(env->allocator, i * sizeof(axis2_char_t) + 1); if (!req_line) { AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); return NULL; } memcpy(req_line, str, i * sizeof(axis2_char_t)); req_line[i] = AXIS2_ESC_NULL; tmp = req_line; method = tmp; tmp = strchr(tmp, AXIS2_SPACE); if (!tmp) { AXIS2_FREE(env->allocator, req_line); AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); return NULL; } *tmp++ = AXIS2_ESC_NULL; uri = tmp; tmp = strrchr(tmp, AXIS2_SPACE); if (!tmp) { AXIS2_FREE(env->allocator, req_line); AXIS2_HANDLE_ERROR(env, AXIS2_ERROR_INVALID_HTTP_HEADER_START_LINE, AXIS2_FAILURE); return NULL; } *tmp++ = AXIS2_ESC_NULL; http_version = tmp; ret = axis2_http_request_line_create(env, method, uri, http_version); AXIS2_FREE(env->allocator, req_line); return ret; }