axis2_status_t rampart_context_set_nodes_to_encrypt_or_sign()

in src/util/rampart_context.c [1295:1391]

• 91 lines of code
• 16 McCabe index (conditional complexity)

axis2_status_t rampart_context_set_nodes_to_encrypt_or_sign(
    rp_header_t *header,
    const axutil_env_t *env,
    axiom_soap_envelope_t *soap_envelope,
    axutil_array_list_t *nodes_to_encrypt_or_sign)
{
    axis2_char_t *nspace = NULL;
    axis2_char_t *local_name = NULL;
    axiom_soap_header_t *soap_header = NULL;
    axiom_node_t *header_node = NULL;

    soap_header = axiom_soap_envelope_get_header(soap_envelope, env);
    if(!soap_header)
        return AXIS2_FAILURE;

    nspace = (axis2_char_t *) rp_header_get_namespace(header, env);
    if(!nspace)
        return AXIS2_FAILURE;

    local_name = (axis2_char_t*) rp_header_get_name(header, env);

    /*if(axutil_strcmp(nspace, RP_SECURITY_NS)==0)*/
    if((axutil_strcmp(nspace, RP_SECURITY_NS)==0) && (!local_name))
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][rampart_context] We do not sign or encrypt security namespace headers");
        return AXIS2_FAILURE;
    }

    if(!local_name)
    {
        axutil_array_list_t *soap_header_blocks = NULL;
        int i = 0;
        soap_header_blocks = axiom_soap_header_get_header_blocks_with_namespace_uri(soap_header, env, nspace);
        if(!soap_header_blocks){
            AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][rampart_context] Header cannot find with namespace %s", nspace);
            return AXIS2_SUCCESS;
        }
        for(i=0 ; i<axutil_array_list_size(soap_header_blocks, env); i++)
        {
            axiom_soap_header_block_t *header_block = NULL;
            axiom_node_t *node = NULL;
            header_block = (axiom_soap_header_block_t *)axutil_array_list_get(soap_header_blocks, env, i);
            if(header_block)
            {
                node = axiom_soap_header_block_get_base_node(header_block, env);
                if(node)
                {
                    axutil_array_list_add(nodes_to_encrypt_or_sign, env, node);
                }
            }
        }/*eof for*/
        axutil_array_list_free(soap_header_blocks, env);
        soap_header_blocks = NULL;
        return AXIS2_SUCCESS;
    }
    else if(axutil_strcmp(local_name,"Security")==0)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[rampart][rampart_context] We do not sign or encrypt %s", local_name);
        return AXIS2_FAILURE;
    }
    else
    {
        axiom_node_t *ret_node = NULL;
        header_node = axiom_soap_header_get_base_node(soap_header, env);
        if(header_node)
        {
            ret_node = oxs_axiom_get_node_by_local_name(env, header_node, local_name);
            if(ret_node)
            {
                axiom_element_t *ret_node_ele = NULL;
                ret_node_ele = (axiom_element_t *)
                               axiom_node_get_data_element(ret_node, env);
                if(ret_node_ele)
                {
                    axiom_namespace_t *ns = NULL;
                    axis2_char_t *namespace_uri = NULL;
                    ns = axiom_element_get_namespace(ret_node_ele, env, ret_node);
                    if(ns)
                    {
                        namespace_uri = axiom_namespace_get_uri(ns, env);
                        if (axutil_strcmp(namespace_uri, nspace) == 0)
                        {
                            axutil_array_list_add(nodes_to_encrypt_or_sign, env, ret_node);
                            return AXIS2_SUCCESS;
                        }
                    }
                }
            }
            else
            {
                AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[rampart][rampart_context] Cannot find the header with name %s", local_name);
                return AXIS2_SUCCESS;
            }
        }
    }
    return AXIS2_SUCCESS;
}