view release on metacpan or  search on metacpan

WSFC_wrap.c  view on Meta::CPAN

	    }

	    nodes[count++] = om_node;

	    do {
		    if (axiom_node_get_node_type(om_node, env) == AXIOM_TEXT) {
			    axiom_text_t *text = NULL;
			    axiom_data_handler_t *data_handler = NULL;
			
			
			    text = (axiom_text_t*)axiom_node_get_data_element(om_node, env);
			    if(text) {
				    data_handler = axiom_text_get_data_handler (text, env);
				    if (data_handler) {
					    axiom_text_set_optimize(text, env, AXIS2_FALSE);
				    }			
			    }
		    }
		    temp_node = axiom_node_get_first_child(om_node, env);
		    if (temp_node)
		    {
			    om_node = temp_node;
			    nodes[count++] = om_node;
		    }
		    else
		    {
			    temp_node = axiom_node_get_next_sibling(om_node, env);
			    if (temp_node)
			    {
				    om_node = temp_node;
				    nodes[count -1] = om_node;
			    }
			    else
			    {
				    while (count > 1 && !temp_node)
				    {
					    count--;
					    om_node = nodes[count -1];
					    temp_node = axiom_node_get_next_sibling(om_node, env);
				    }
               
				    if (temp_node && count > 1)
				    {
					    om_node = temp_node;
					    nodes[count -1] = om_node;
				    }
				    else
				    {
					    count--;
				    }
			    }
		    }
	    } while(count > 0);
    
	    return;
    }


        void wsf_set_security_data_to_rampart_context(axutil_env_t *env,
						  rampart_context_t *rampart_context,
						  axis2_char_t *private_key,
						  axis2_char_t *certificate,
						  axis2_char_t *receiver_certificate,
						  axis2_char_t *user,
						  axis2_char_t *password,
						  axis2_char_t *password_type,
						  int ttl)
    {
	    if (NULL != private_key) {
		    if (rampart_context_set_prv_key(rampart_context, env, (void *) private_key) == AXIS2_SUCCESS)
			     AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting pvt key ");
		    if (rampart_context_set_prv_key_type(rampart_context, env, AXIS2_KEY_TYPE_PEM) == AXIS2_SUCCESS)
			    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting pvt key format ");
	    }

	    if (NULL != certificate) {
		    if (rampart_context_set_certificate(rampart_context, env, (void *)certificate) == AXIS2_SUCCESS)
			    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting pub key");
		    if (rampart_context_set_certificate_type(rampart_context, env, AXIS2_KEY_TYPE_PEM) == AXIS2_SUCCESS)
			    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting pub key type");
	    }

	    if (NULL != receiver_certificate) {
		    if (rampart_context_set_receiver_certificate(rampart_context, env, receiver_certificate) == AXIS2_SUCCESS)
			    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting receiver pub key");
		    if (rampart_context_set_receiver_certificate_type(rampart_context, env, AXIS2_KEY_TYPE_PEM) == AXIS2_SUCCESS)
			    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting receiver pub key format");
	    }

	    if ((NULL != user) && (rampart_context_set_user(rampart_context, env, user) == AXIS2_SUCCESS))
		    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting username ");

	    if ((NULL != password) && (rampart_context_set_password(rampart_context, env, password) == AXIS2_SUCCESS))
		    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting password ");

	    if ((NULL != password_type) && (rampart_context_set_password_type(rampart_context, env, password_type) == AXIS2_SUCCESS))
		    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy] setting password type ");

	    if ((ttl > 0) && (rampart_context_set_ttl(rampart_context, env, ttl) == AXIS2_SUCCESS))
		    AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[wsf_sec_policy) setting ttl");

    }
	    

    void handle_client_security(axutil_env_t *env, 
				axis2_svc_client_t *svc_client,
				axiom_node_t *incoming_policy_node,
				axis2_char_t *private_key,
				axis2_char_t *certificate,
				axis2_char_t *receiver_certificate,
				axis2_char_t *user,
				axis2_char_t *password,
				axis2_char_t *password_type,
				int ttl)
    {
	    axiom_element_t *root = NULL;
	    neethi_policy_t *neethi_policy = NULL;
	    axis2_svc_t *svc = NULL;
	    axis2_desc_t *desc = NULL;
	    axis2_policy_include_t *policy_include = NULL;
	    axis2_svc_ctx_t *svc_ctx = NULL;
	    axis2_conf_ctx_t *conf_ctx = NULL;
	    axis2_conf_t *conf = NULL;
	    axutil_param_t *security_param = NULL;
	    rampart_context_t *rampart_ctx = NULL;

	    if (NULL != incoming_policy_node) {
		    if (axiom_node_get_node_type(incoming_policy_node, env) == AXIOM_ELEMENT) {
			    root = (axiom_element_t *) axiom_node_get_data_element(incoming_policy_node, env);
			    if (NULL != root) {
				    neethi_policy = neethi_engine_get_policy(env, incoming_policy_node, root);
				    if (NULL != neethi_policy) {
					    svc = axis2_svc_client_get_svc(svc_client, env);
					    if (NULL != svc) {
						    desc = axis2_svc_get_base(svc, env);
						    policy_include = axis2_desc_get_policy_include(desc, env);
						    axis2_policy_include_add_policy_element(policy_include, env, AXIS2_SERVICE_POLICY, neethi_policy);
						    svc_ctx = axis2_svc_client_get_svc_ctx(svc_client, env);
						    if (NULL != svc_ctx) {
							    conf_ctx = axis2_svc_ctx_get_conf_ctx(svc_ctx, env);
							    if (NULL != conf_ctx) {
								    conf = axis2_conf_ctx_get_conf(conf_ctx, env);
								    if (NULL != conf) {
									    rampart_ctx = rampart_context_create(env);
									    wsf_set_security_data_to_rampart_context(env, rampart_ctx, private_key, certificate, receiver_certificate, user, password, password_type, ttl);
									    security_param = axutil_param_create(env, (axis2_char_t *) WSF_RAMPART_CONFIGURATION, rampart_ctx);
									    if (NULL != security_param) 
										    axis2_conf_add_param(conf, env, security_param);
								    }
							    }
						    }
					    }
				    }
			    }
		    }
	    }
	    axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_RAMPART);

    }


				



SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
{
  if (SvPOK(obj)) {
    STRLEN len = 0;
    char *cstr = SvPV(obj, len); 
    size_t size = len + 1;
    if (cptr)  {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      char* vptr = 0; 
      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = vptr;
	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;