trunk/test/aaip_0_2.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	Aaip_h_is_includeD   yes
Functions
unsigned int	aaip_encode (char aa_name[2], unsigned int num_attrs, char **names, size_t *attr_lengths, char **attrs, size_t *result_len, unsigned char **result, int flag)
int	aaip_encode_acl (char *acl_text, size_t *result_len, unsigned char **result, int flag)
size_t	aaip_sizeof_aaip_state (void)
int	aaip_init (struct aaip_state *aaip, char aa_name[2], int flag)
int	aaip_submit_data (struct aaip_state *aaip, unsigned char *data, size_t num_data, size_t *ready_bytes, int flag)
int	aaip_fetch_data (struct aaip_state *aaip, char *result, size_t result_size, size_t *num_result, int flag)
int	aaip_skip_component (struct aaip_state *aaip, int flag)
int	aaip_decode_pair (struct aaip_state *aaip, unsigned char *data, size_t num_data, size_t *consumed, char *name, size_t name_size, size_t *name_fill, char *value, size_t value_size, size_t *value_fill, int flag)
unsigned int	aaip_get_pairs_skipped (struct aaip_state *aaip, int flag)
int	aaip_decode_acl (unsigned char *data, size_t num_data, size_t *consumed, char *acl_text, size_t acl_text_size, size_t *acl_text_fill, int flag)

---

Define Documentation

#define Aaip_h_is_includeD   yes

Definition at line 14 of file aaip_0_2.h.

---

Function Documentation

int aaip_decode_acl	(	unsigned char *	data,
		size_t	num_data,
		size_t *	consumed,
		char *	acl_text,
		size_t	acl_text_size,
		size_t *	acl_text_fill,
		int	flag
	)

Definition at line 1232 of file aaip_0_2.c.

References Aaip_ACL_GROUP, Aaip_ACL_GROUP_N, Aaip_ACL_GROUP_OBJ, Aaip_ACL_MASK, Aaip_ACL_OTHER, Aaip_ACL_USER, Aaip_ACL_USER_N, Aaip_ACL_USER_OBJ, Aaip_EXEC, Aaip_FUTURE_VERSION, Aaip_READ, aaip_read_qualifier(), Aaip_SWITCH_MARK, Aaip_TRANSLATE, Aaip_WRITE, and aaip_write_acl_line().

Referenced by decode_acl().

{
 unsigned char *rpt;
 char perm_text[4], *wpt, name[1024];
 int type, qualifier= 0, perm, ret, i, cnt;
 size_t w_size, name_fill;
 uid_t uid;
 gid_t gid;
 struct passwd *pwd;
 struct group *grp;

 cnt= flag & 1;
 *consumed= 0;
 wpt= acl_text;
 w_size= acl_text_size;
 *acl_text_fill= 0;
 for(rpt= data; rpt - data < num_data; ) {
   perm= *rpt;
   strcpy(perm_text, "---");
   if(perm & Aaip_READ)
     perm_text[0]= 'r';
   if(perm & Aaip_WRITE)
     perm_text[1]= 'w';
   if(perm & Aaip_EXEC)
     perm_text[2]= 'x';
     
   type= (*rpt) >> 4;
   if(type == Aaip_FUTURE_VERSION) /* indicate to caller: version mismatch */
     return(-3);

   qualifier= !!((*rpt) & 8);
   if(qualifier) {
     ret= aaip_read_qualifier(rpt + 1, num_data - (rpt + 1 - data),
                              name, sizeof(name), &name_fill, 0);
     if(ret <= 0)
       return(-1);
   }

   /* Advance read pointer */
   (*consumed)+= 1 + (qualifier ? name_fill + 1 : 0);
   rpt+= 1 + (qualifier ? name_fill + 1 : 0);

   ret= 1;
   if(type == Aaip_TRANSLATE) {
     /* rightfully ignored yet */;
 continue;
   } else if(type == Aaip_ACL_USER_OBJ) {
     /* user::rwx */
     ret= aaip_write_acl_line(&wpt, &w_size, "user", "", perm_text, cnt);
   } else if(type == Aaip_ACL_USER) {
     /* user:<username>:rwx */;
     ret= aaip_write_acl_line(&wpt, &w_size, "user", name, perm_text, cnt);
   } else if(type == Aaip_ACL_GROUP_OBJ) {
     /* user::rwx */
     ret= aaip_write_acl_line(&wpt, &w_size, "group", "", perm_text, cnt);
   } else if(type == Aaip_ACL_GROUP) {
     /* group:<groupname>:rwx */;
     ret= aaip_write_acl_line(&wpt, &w_size, "group", name, perm_text, cnt);
   } else if(type == Aaip_ACL_MASK) {
     /* mask::rwx */
     ret= aaip_write_acl_line(&wpt, &w_size, "mask", "", perm_text, cnt);
   } else if(type == Aaip_ACL_OTHER) {
     /* other::rwx */
     ret= aaip_write_acl_line(&wpt, &w_size, "other", "", perm_text, cnt);
   } else if(type == Aaip_SWITCH_MARK) {
     /* Indicate to caller: end of desired ACL type access/default */
     if((!(perm & Aaip_EXEC)) ^ (!!(flag & 2)))
       return(2);
   } else if(type == Aaip_ACL_USER_N) {
     /* determine username from uid */
     uid= 0;
     for(i= 0; i < name_fill; i++)
       uid= (uid << 8) | ((unsigned char *) name)[i];
     pwd= getpwuid(uid);
     if(pwd == NULL)
       sprintf(name, "%.f", (double) uid);
     else if(strlen(pwd->pw_name) >= sizeof(name))
       sprintf(name, "%.f", (double) uid);
     else
       strcpy(name, pwd->pw_name);
     /* user:<username>:rwx */;
     ret= aaip_write_acl_line(&wpt, &w_size, "user", name, perm_text, cnt);
   } else if(type == Aaip_ACL_GROUP_N) {
     /* determine username from gid */;
     gid= 0;
     for(i= 0; i < name_fill; i++)
       gid= (gid << 8) | ((unsigned char *) name)[i];
     grp= getgrgid(gid);
     if(grp == NULL)
       sprintf(name, "%.f", (double) gid);
     else if(strlen(grp->gr_name) >= sizeof(name))
       sprintf(name, "%.f", (double) gid);
     else
       strcpy(name, grp->gr_name);
     /* user:<username>:rwx */;
     ret= aaip_write_acl_line(&wpt, &w_size, "group", name, perm_text, cnt);
   } else {
     /* indicate to caller: unknown type */
     return(-4);
   }
   if(ret <= 0)
     return(-2);
 }
 if(flag & 1)
   *acl_text_fill= w_size + 1;
 return(1);
}

int aaip_decode_pair	(	struct aaip_state *	aaip,
		unsigned char *	data,
		size_t	num_data,
		size_t *	consumed,
		char *	name,
		size_t	name_size,
		size_t *	name_fill,
		char *	value,
		size_t	value_size,
		size_t *	value_fill,
		int	flag
	)

Definition at line 1086 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_advance_pair(), aaip_fetch_data(), aaip_submit_data(), aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, and aaip_state::pair_status.

Referenced by main().

{
 int ret;
 size_t ready_bytes;

 *consumed= 0;
 if(aaip->pair_status < 0 || aaip->pair_status == 4 ||
    aaip->pair_status == 5) { /* dead ends */
   ret= aaip->pair_status;
   goto ex;
 } else if(aaip->pair_status == 2 || aaip->pair_status == 3) {
   if(aaip->pair_status == 3 && num_data > 0)
     {ret= 0; goto ex;}
   /* Start a new pair */
   if(!aaip->first_is_name) /* Eventually skip orphaned value */
     aaip_fetch_data(aaip, NULL, (size_t) 0, NULL, 1);
   *name_fill= *value_fill= 0;
 }

 if(num_data > 0) {
   ret= aaip_submit_data(aaip, data, num_data, &ready_bytes, 0);
 } else {
   ret= 1;
   if(aaip->num_components)
     ret= 3;
   else if(aaip->num_recs)
     ret= 2;
 }
 if(ret < 0) { /* non-AA field detected */
   *consumed= ready_bytes;
   {ret= -1; goto ex;}
 } else if(ret == 0) { /* buffer overflow */;
   /* should not happen with correct usage */ 
   {ret= -2; goto ex;}
 } else if(ret == 1) { /* no component record complete */
   goto ex;
 } else if(ret == 2) { /* component record complete, may be delivered */
   ;
 } else if(ret == 3) { /* component complete, may be delivered */
   ;
 } else if(ret == 4) { /* no component available, no more data expected */
   {ret= 5; goto ex;}
 } else 
   {ret= -1; goto ex;} /* unknown reply from aaip_submit_data() */

 *consumed= num_data;
 ret= aaip_advance_pair(aaip, name, name_size, name_fill,
                        value, value_size, value_fill, 0);
 if(aaip->aa_ends == 3) {
   if(ret >= 2 && ret <= 4)
     ret= 4;
   else
     ret= 5;
 }
ex:;
 aaip->pair_status= ret;
 return(ret);
}

unsigned int aaip_encode	(	char	aa_name[2],
		unsigned int	num_attrs,
		char **	names,
		size_t *	attr_lengths,
		char **	attrs,
		size_t *	result_len,
		unsigned char **	result,
		int	flag
	)

Definition at line 68 of file aaip_0_2.c.

References aaip_encode_pair().

Referenced by main().

{
 size_t mem_size= 0, comp_size;
 unsigned int number_of_fields, i, num_recs, total_recs= 0, ret;

 /* Predict memory needs, number of SUSP fields and component records */
 *result_len= 0;
 for(i= 0; i < num_attrs; i++) {
   ret= aaip_encode_pair(names[i], attr_lengths[i], attrs[i],
                         &num_recs, &comp_size, NULL, (size_t) 0, 1);
   if(ret <= 0)
     return(ret);
   mem_size+= comp_size;
   total_recs= num_recs;
 }
 number_of_fields= mem_size / 250 + !!(mem_size % 250);
 mem_size+= number_of_fields * 5;

#ifdef Aaip_encode_debuG
 *result= (unsigned char *) calloc(1, mem_size + 1024000);
                                          /* generous honeypot for overflows */
#else
 *result= (unsigned char *) calloc(1, mem_size);
#endif


 /* Encode pairs into result */
 for(i= 0; i < num_attrs; i++) {
   ret= aaip_encode_pair(names[i], attr_lengths[i], attrs[i],
                         &num_recs, &comp_size, *result, *result_len, 0);
   if(ret <= 0)
     return(ret);
   (*result_len)+= comp_size;
 }

 /* write the field headers */
 for(i= 0; i < number_of_fields; i++) {
   (*result)[i * 255 + 0]= aa_name[0];
   (*result)[i * 255 + 1]= aa_name[1];
   if(i < number_of_fields - 1 || (mem_size % 255) == 0)
     (*result)[i * 255 + 2]= 255;
   else 
     (*result)[i * 255 + 2]= mem_size % 255;
   (*result)[i * 255 + 3]= 1;
   (*result)[i * 255 + 4]= (flag & 1) || (i < number_of_fields - 1);
 }
 (*result_len)+= number_of_fields * 5;

#ifdef Aaip_encode_debuG
 if(*result_len != mem_size) {
   fprintf(stderr, "aaip_encode(): MEMORY MISMATCH BY %d BYTES\n",
           (int) (mem_size - *result_len));
 }
 ret= 0;
 for(i= 0; i < *result_len; i+= ((unsigned char *) (*result))[i + 2])
   ret++;
 if(ret != number_of_fields) {
   fprintf(stderr, "aaip_encode(): WRONG NUMBER OF FIELDS %d <> %d\n",
           number_of_fields, ret);
 }
#endif /* Aaip_encode_debuG */

 return(number_of_fields);
}

int aaip_encode_acl	(	char *	acl_text,
		size_t *	result_len,
		unsigned char **	result,
		int	flag
	)

Definition at line 215 of file aaip_0_2.c.

References aaip_encode_acl_text().

Referenced by test_acl().

{
 ssize_t bytes;

 *result= NULL;
 *result_len= 0;
 bytes= aaip_encode_acl_text(acl_text, (size_t) 0, NULL, 1 | (flag & 6));
 if(bytes < 0)
   return(0);
 if(flag & 1) {
   *result_len= bytes;
   return(1);
 }
 *result= calloc(bytes + 1, 1);
 if(*result == NULL)
   return(-1);
 (*result)[bytes]= 0;
 *result_len= bytes;
 bytes= aaip_encode_acl_text(acl_text, *result_len, *result, (flag & 6));
 if(bytes != *result_len) {
   *result_len= 0;
   return(0);
 }
 return(1);
}

int aaip_fetch_data	(	struct aaip_state *	aaip,
		char *	result,
		size_t	result_size,
		size_t *	num_result,
		int	flag
	)

Definition at line 913 of file aaip_0_2.c.

References aaip_get_buffer_byte(), aaip_read_from_recs(), aaip_shift_recs(), aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, and aaip_state::ready_bytes.

Referenced by aaip_advance_pair(), aaip_decode_pair(), and aaip_skip_component().

{
 int ret= -1, complete= 0, payload;
 unsigned int i, num_bytes= 0, h;

 if(aaip->num_recs == 0)
   return(-1);

 /* Copy data until end of buffer or end of component */
 h= 0;
 for(i= 0; i < aaip->num_recs && !complete; i++) {
   payload= aaip_get_buffer_byte(aaip, h + 1, 0);
   if(!(flag & 1)) {
     if(num_bytes + payload > result_size)
       return(-2);
     aaip_read_from_recs(aaip, h + 2, (unsigned char *) (result + num_bytes),
                         payload, 0);
     *num_result= num_bytes + payload;
   }
   num_bytes+= payload;
   if(!(aaip_get_buffer_byte(aaip, h, 0) & 1))
     complete= 1;
   h+= payload + 2;
 }
 aaip->ready_bytes-= num_bytes;
 aaip->num_recs-= i;

 /* Shift buffer */
 aaip_shift_recs(aaip, h, 0);

 /* Compute reply */
 ret= 2 * !aaip->first_is_name;
 if(complete) {
   aaip->first_is_name= !aaip->first_is_name;
   if(aaip->num_components > 0)
     aaip->num_components--;
 } else
   ret|= 1;

 return(ret);
}

unsigned int aaip_get_pairs_skipped	(	struct aaip_state *	aaip,
		int	flag
	)

Definition at line 1150 of file aaip_0_2.c.

References aaip_state::pairs_skipped.

Referenced by main().

{
 return(aaip->pairs_skipped);
}

int aaip_init	(	struct aaip_state *	aaip,
		char	aa_name[2],
		int	flag
	)

Definition at line 475 of file aaip_0_2.c.

References aaip_state::aa_head_missing, aaip_state::aa_missing, aaip_state::aa_name, Aaip_buffer_reservE, Aaip_buffer_sizE, aaip_state::end_of_components, aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, aaip_state::pair_status, aaip_state::pairs_skipped, aaip_state::ready_bytes, aaip_state::rec_ends, aaip_state::rec_head_missing, aaip_state::rec_missing, aaip_state::recs, aaip_state::recs_fill, aaip_state::recs_invalid, and aaip_state::recs_start.

Referenced by main().

{
 aaip->aa_name[0]= aa_name[0];
 aaip->aa_name[1]= aa_name[1];
 aaip->aa_head_missing= 5;
 aaip->aa_missing= 0;

 aaip->recs_invalid= 0;
 memset(aaip->recs, 0, Aaip_buffer_sizE + Aaip_buffer_reservE);
 aaip->recs_fill= 0;
 aaip->recs_start= aaip->recs;
 aaip->rec_head_missing= 2;
 aaip->rec_missing= 0;
 aaip->rec_ends= 0;

 aaip->num_recs= 0;
 aaip->ready_bytes= 0;

 aaip->num_components= 0;
 aaip->end_of_components= 0;
 aaip->first_is_name= 1;

 aaip->pair_status= 2;
 aaip->pairs_skipped= 0;

 return(1);
}

size_t aaip_sizeof_aaip_state

(

void

)

Definition at line 469 of file aaip_0_2.c.

Referenced by main().

{
 return((size_t) sizeof(struct aaip_state));
}

int aaip_skip_component	(	struct aaip_state *	aaip,
		int	flag
	)

Definition at line 968 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_fetch_data(), aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, aaip_state::ready_bytes, aaip_state::recs_fill, and aaip_state::recs_invalid.

Referenced by aaip_advance_pair().

{
 int to_skip= 1;

 if(aaip->first_is_name && !(flag & 1))
   to_skip= 2;
 if(aaip->recs_invalid) {
   aaip->recs_invalid+= to_skip;
   return(1);
 }

 if(aaip->num_components) {
   /* null-fetch */
   aaip_fetch_data(aaip, NULL, (size_t) 0, NULL, 1);
   to_skip--;
 }
 if(aaip->num_components && to_skip) {
   /* null-fetch */
   aaip_fetch_data(aaip, NULL, (size_t) 0, NULL, 1);
   to_skip--;
 }
 if(to_skip) {
   aaip->recs_fill= 0;
   aaip->num_recs= 0;
   aaip->ready_bytes= 0;
 }
 aaip->recs_invalid= to_skip;
 if(aaip->aa_ends == 2 && aaip->num_recs == 0)
   aaip->aa_ends= 3;
 return(1 + (aaip->num_recs > 0));
}

int aaip_submit_data	(	struct aaip_state *	aaip,
		unsigned char *	data,
		size_t	num_data,
		size_t *	ready_bytes,
		int	flag
	)

Definition at line 852 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_state::aa_head_missing, aaip_state::aa_missing, Aaip_buffer_sizE, aaip_consume_aa_data(), aaip_consume_aa_head(), aaip_state::num_components, aaip_state::num_recs, aaip_state::ready_bytes, and aaip_state::recs_fill.

Referenced by aaip_advance_pair(), and aaip_decode_pair().

{
 int ret;
 unsigned char *in_data;

 if(aaip->aa_ends == 3)
   return(4);
 in_data= data;
 if(num_data == 0)
   goto ex;
 if(aaip->recs_fill + num_data > Aaip_buffer_sizE)
   return(0);
 
 while(num_data > 0) {
   if(aaip->aa_head_missing > 0) {
     ret= aaip_consume_aa_head(aaip, &data, &num_data, 0);
     if(ret < 0) {
       *ready_bytes= data - in_data;
       return(-1);
     }
     if(num_data == 0 || aaip->aa_missing <= 0)
       goto ex;
   }
   aaip_consume_aa_data(aaip, &data, &num_data, 0);
   if(aaip->aa_missing)
 break;
 }
ex:;
 *ready_bytes= aaip->ready_bytes;
 if(aaip->num_components > 0)
   return(3);
 if(aaip->num_recs > 0)
   return(2);
 if(aaip->aa_ends && aaip->aa_head_missing == 0 && aaip->aa_missing == 0)
   aaip->aa_ends= 2;
 if(aaip->aa_ends == 2 && aaip->num_recs == 0)
   aaip->aa_ends= 3;
 if(aaip->aa_ends == 3)
   return(4);
 return(1);
}