int sec_object_getvalue(void * sec_obj,char * valuename,void * value)
{
int ret;
SEC_OBJECT * sec_object=(SEC_OBJECT *)sec_obj;
if(sec_object==NULL)
return -EINVAL;
pthread_rwlock_wrlock(&(sec_object->rwlock));
ret=struct_read_elem(valuename,sec_object->share_data,value,sec_object->struct_template);
pthread_rwlock_unlock(&(sec_object->rwlock));
return ret;
}
int rule_get_target(void * router_rule,void * message,void **result)
{
BYTE * target;
int ret;
char buffer[DIGEST_SIZE*2];
ROUTE_RULE * rule= (ROUTE_RULE *)router_rule;
*result=NULL;
switch(rule->target_type){
case ROUTE_TARGET_NAME:
case ROUTE_TARGET_PORT:
case ROUTE_TARGET_LOCAL:
target=Talloc0(DIGEST_SIZE);
Strncpy(target,rule->target_name,DIGEST_SIZE);
break;
case ROUTE_TARGET_UUID:
ret=Strnlen(rule->target_name,DIGEST_SIZE*2);
target=Talloc0(DIGEST_SIZE);
if(ret ==DIGEST_SIZE*2)
{
if(target==NULL)
return -ENOMEM;
ret=uuid_to_digest(rule->target_name,target);
if(ret<0)
return ret;
}
else if(ret<DIGEST_SIZE/4*3)
{
Memcpy(target,rule->target_name,ret);
}
else
return -EINVAL;
break;
case ROUTE_TARGET_CONN:
target=Talloc0(DIGEST_SIZE);
if(target==NULL)
return -ENOMEM;
ret=Strnlen(rule->target_name,DIGEST_SIZE*2);
if(ret>DIGEST_SIZE/4*3-1)
return -EINVAL;
target[0]=':';
Memcpy(target+1,rule->target_name,ret);
break;
case ROUTE_TARGET_RECORD:
{
ret=message_read_elem(message,rule->target_name,0,&target);
if(ret<0)
return -EINVAL;
if(target==NULL)
return -EINVAL;
break;
}
case ROUTE_TARGET_EXPAND:
{
int expand_type;
int expand_subtype;
MSG_EXPAND * expand;
void * expand_template;
void * expand_data;
int len;
len=Strlen(rule->target_name);
if(len>DIGEST_SIZE*3)
return -EINVAL;
int i=0;
int offset=0;
offset=message_read_typestr(rule->target_name,&expand_type,&expand_subtype);
if(offset<0)
return offset;
while(rule->target_name[offset++]!=':')
{
if(offset>=len)
return -EINVAL;
}
ret = message_get_define_expand(message,&expand,expand_type,expand_subtype);
if(ret<0)
return -EINVAL;
if(expand==NULL)
return -EINVAL;
expand_template=memdb_get_template(expand_type,expand_subtype);
if(expand_template==NULL)
return -EINVAL;
target=Talloc(DIGEST_SIZE*2+1);
ret=struct_read_elem(rule->target_name+offset,expand->expand,target,expand_template);
if(ret<0)
return ret;
if(target==NULL)
return -EINVAL;
break;
}
/*
case ROUTE_TARGET_SPLIT:
return -EINVAL;
case ROUTE_TARGET_MIXUUID:
{
void * json_root;
void * json_elem;
const int repeat_time=2;
char mixvalue[repeat_time][DIGEST_SIZE*2];
char tag[16];
char uuid[DIGEST_SIZE*2];
int i;
ret=json_solve_str(&json_root,rule->target_name);
if(ret<0)
return ret;
if(json_get_type(json_root)!=JSON_ELEM_MAP)
return -EINVAL;
memset(uuid,0,DIGEST_SIZE*2);
char * value;
char name[DIGEST_SIZE*2];
for(i=0;i<repeat_time;i++)
{
memset(mixvalue[i],0,DIGEST_SIZE*2);
if(i==0)
{
// first json_elem is the node uuid value
json_elem=json_get_first_child(json_root);
}
else
{
json_elem=json_get_next_child(json_root);
}
ret=json_node_getname(json_elem,name);
if(ret<0)
return ret;
if(json_get_type(json_elem)!=JSON_ELEM_STRING)
return -EINVAL;
ret=json_node_getvalue(json_elem,tag,15);
// tag is "RECORD" means this elem defines an elem in the message's record
if(strcmp(tag,"RECORD")==0)
{
void * record;
ret=message_read_elem(message,name,0,&record);
if(ret<0)
return ret;
int len=strlen(record);
if(len<DIGEST_SIZE*2)
{
Memcpy(mixvalue[i],record,len);
}
else
{
Memcpy(mixvalue[i],record,DIGEST_SIZE*2);
}
}
// tag is "name" means this elem defines remote proc's value
else if(strcmp(tag,"NAME")==0)
{
int len=strlen(name);
if(len<DIGEST_SIZE*2)
{
Memcpy(mixvalue[i],name,len);
}
else
{
Memcpy(mixvalue[i],name,DIGEST_SIZE*2);
}
}
else if(strncmp(tag,"EXPAND",6)==0)
{
char * type=tag+7;
if(strlen(type)!=4)
{
return -EINVAL;
}
void * expand;
ret = message_get_define_expand(message,&expand,type);
if(ret<0)
return -EINVAL;
if(expand==NULL)
return -EINVAL;
void * struct_template=load_record_template(type);
if(struct_template==NULL)
return -EINVAL;
ret=struct_read_elem(name,expand,mixvalue[i],struct_template);
free_struct_template(struct_template);
if(ret<0)
return ret;
}
else
{
return -EINVAL;
}
if(i==0)
continue;
if(i==1)
{
comp_proc_uuid(mixvalue[0],mixvalue[1],uuid);
continue;
}
comp_proc_uuid(uuid,mixvalue[i],uuid);
}
target=malloc(DIGEST_SIZE*2);
Memcpy(target,uuid,DIGEST_SIZE*2);
break;
}
*/
case ROUTE_TARGET_ERROR:
default:
return -EINVAL;
}
*result=target;
return rule->target_type;
}
