trunk/test/aaip_0_2.c File Reference

#include <ctype.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <pwd.h>
#include <grp.h>
#include "aaip_0_2.h"

Include dependency graph for aaip_0_2.c:

Go to the source code of this file.

Data Structures
struct	aaip_state
Defines
#define	Aaip_encode_debuG   1
#define	Aaip_EXEC   1
#define	Aaip_WRITE   2
#define	Aaip_READ   4
#define	Aaip_TRANSLATE   0
#define	Aaip_ACL_USER_OBJ   1
#define	Aaip_ACL_USER   2
#define	Aaip_ACL_GROUP_OBJ   3
#define	Aaip_ACL_GROUP   4
#define	Aaip_ACL_MASK   5
#define	Aaip_ACL_OTHER   6
#define	Aaip_SWITCH_MARK   8
#define	Aaip_ACL_USER_N   10
#define	Aaip_ACL_GROUP_N   12
#define	Aaip_FUTURE_VERSION   15
#define	Aaip_buffer_sizE   4096
#define	Aaip_buffer_reservE   (257 + 3 * 2)
#define	Aaip_with_ring_buffeR   yes
Functions
static int	aaip_encode_pair (char *name, size_t attr_length, char *attr, unsigned int *num_recs, size_t *comp_size, unsigned char *result, size_t result_fill, int flag)
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)
static void	aaip_encode_byte (unsigned char *result, size_t *result_fill, unsigned char value)
static int	aaip_encode_comp (unsigned char *result, size_t *result_fill, char *data, size_t l, int flag)
static ssize_t	aaip_encode_acl_text (char *acl_text, size_t result_size, unsigned char *result, int flag)
int	aaip_encode_acl (char *acl_text, size_t *result_len, unsigned char **result, int flag)
static double	aaip_numeric_id (char *name, int flag)
size_t	aaip_sizeof_aaip_state (void)
int	aaip_init (struct aaip_state *aaip, char aa_name[2], int flag)
static int	aaip_ring_adr (struct aaip_state *aaip, size_t idx, size_t todo, unsigned char **start_pt, size_t *at_start_pt, size_t *at_recs, int flag)
static int	aaip_push_to_recs (struct aaip_state *aaip, unsigned char *data, size_t todo, int flag)
static int	aaip_read_from_recs (struct aaip_state *aaip, size_t idx, unsigned char *data, size_t num_data, int flag)
static int	aaip_set_buffer_byte (struct aaip_state *aaip, size_t idx, unsigned char data, int flag)
static int	aaip_get_buffer_byte (struct aaip_state *aaip, size_t idx, int flag)
static int	aaip_shift_recs (struct aaip_state *aaip, size_t todo, int flag)
static int	aaip_consume_rec_head (struct aaip_state *aaip, unsigned char **data, size_t *num_data, int flag)
static int	aaip_consume_rec_data (struct aaip_state *aaip, unsigned char **data, size_t *num_data, int flag)
static int	aaip_consume_aa_head (struct aaip_state *aaip, unsigned char **data, size_t *num_data, int flag)
static int	aaip_consume_aa_data (struct aaip_state *aaip, unsigned char **data, size_t *num_data, 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)
static int	aaip_advance_pair (struct aaip_state *aaip, char *name, size_t name_size, size_t *name_fill, char *value, size_t value_size, size_t *value_fill, 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)
static int	aaip_write_acl_line (char **result, size_t *result_size, char *tag_type, char *qualifier, char *permissions, int flag)
static int	aaip_read_qualifier (unsigned char *data, size_t num_data, char *name, size_t name_size, size_t *name_fill, 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_ACL_GROUP   4

Definition at line 36 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_GROUP_N   12

Definition at line 41 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_GROUP_OBJ   3

Definition at line 35 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_MASK   5

Definition at line 37 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_OTHER   6

Definition at line 38 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_USER   2

Definition at line 34 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_USER_N   10

Definition at line 40 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_ACL_USER_OBJ   1

Definition at line 33 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_buffer_reservE   (257 + 3 * 2)

Definition at line 429 of file aaip_0_2.c.

Referenced by aaip_init(), and aaip_ring_adr().

#define Aaip_buffer_sizE   4096

Definition at line 424 of file aaip_0_2.c.

Referenced by aaip_init(), aaip_ring_adr(), and aaip_submit_data().

#define Aaip_encode_debuG   1

Definition at line 24 of file aaip_0_2.c.

#define Aaip_EXEC   1

Definition at line 28 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_FUTURE_VERSION   15

Definition at line 42 of file aaip_0_2.c.

Referenced by aaip_decode_acl().

#define Aaip_READ   4

Definition at line 30 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_SWITCH_MARK   8

Definition at line 39 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

#define Aaip_TRANSLATE   0

Definition at line 32 of file aaip_0_2.c.

Referenced by aaip_decode_acl().

#define Aaip_with_ring_buffeR   yes

Definition at line 505 of file aaip_0_2.c.

#define Aaip_WRITE   2

Definition at line 29 of file aaip_0_2.c.

Referenced by aaip_decode_acl(), and aaip_encode_acl_text().

---

Function Documentation

static int aaip_advance_pair	(	struct aaip_state *	aaip,
		char *	name,
		size_t	name_size,
		size_t *	name_fill,
		char *	value,
		size_t	value_size,
		size_t *	value_fill,
		int	flag
	)			[static]

Definition at line 1004 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_fetch_data(), aaip_skip_component(), aaip_submit_data(), aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, and aaip_state::pairs_skipped.

Referenced by aaip_decode_pair().

{
 int ret;
 char *wpt;
 size_t size, num;

retry:;
 if(aaip->first_is_name) {
   wpt= name + *name_fill;
   size= name_size - *name_fill;
 } else {
   wpt= value + *value_fill;
   size= value_size - *value_fill;
 }
 ret= aaip_fetch_data(aaip, wpt, size, &num, 0);
 if(ret == -2) {                                 /* insufficient result size */
   ret= aaip_skip_component(aaip, 0);
   *name_fill= *value_fill= 0;
   aaip->pairs_skipped++;
   if(ret == 2) /* Skip performed, valid data pending */
     goto retry;
 } else if(ret == -1) {       /* No data ready for delivery : may not happen */
   return(-1);
 } else if(ret == 0) {              /* result holds the final part of a name */
   (*name_fill)+= num;
   /* peek for value data */
   ret= aaip_submit_data(aaip, NULL, (size_t) 0, &num, 0);
   if(ret == 2 || ret == 3) {
     /* fetch value data */;
     ret= aaip_advance_pair(aaip, name, name_size, name_fill,
                            value, value_size, value_fill, flag);
     return ret;
   } else if(ret == 4)
     return(5);
 } else if(ret == 1) {        /* result holds an intermediate part of a name */
   (*name_fill)+= num;
 } else if(ret == 2) {             /* result holds the final part of a value */
   (*value_fill)+= num;
   if(aaip->num_components >= 2)
     return(3);
   if(aaip->aa_ends == 2 && aaip->num_recs == 0)
     aaip->aa_ends= 3;
   if(aaip->aa_ends == 3)
     return(4);
   return(2);
 } else if(ret == 3) {
   /* result holds an intermediate part of a value */;
   (*value_fill)+= num;
 } else {
   return(-1); /* unknown reply from aaip_fetch_data() */
 }
 return(1);
}

static int aaip_consume_aa_data	(	struct aaip_state *	aaip,
		unsigned char **	data,
		size_t *	num_data,
		int	flag
	)			[static]

Definition at line 776 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_state::aa_head_missing, aaip_state::aa_missing, aaip_consume_rec_data(), aaip_consume_rec_head(), aaip_push_to_recs(), aaip_set_buffer_byte(), aaip_state::end_of_components, aaip_state::first_is_name, aaip_state::num_components, aaip_state::num_recs, aaip_state::rec_ends, aaip_state::rec_head_missing, aaip_state::rec_missing, and aaip_state::recs_fill.

Referenced by aaip_submit_data().

{
 size_t i;
 static unsigned char zero_char[2]= {0, 0};

 while(*num_data > 0 && aaip->aa_missing > 0) {
   if(aaip->rec_head_missing > 0) {
     aaip_consume_rec_head(aaip, data, num_data, 0);
     if(*num_data == 0 || aaip->aa_missing <= 0)
       return(1);
   }
   aaip_consume_rec_data(aaip, data, num_data, 0);
 }
 if(aaip->aa_missing <= 0) {
   if(aaip->aa_ends) {
     /* Check for incomplete pair and eventually make emergency closure */
     if(aaip->rec_head_missing != 2) {         /* incomplete record detected */
       if(aaip->rec_head_missing) {
         /* fake 0 length record */
         aaip_set_buffer_byte(aaip, aaip->recs_fill - 1, (unsigned char) 0, 0);
         aaip_push_to_recs(aaip, zero_char, 1, 0);
       } else {
         /* fill in missing btes */
         for(i= 0; i < aaip->rec_missing; i++)
           aaip_push_to_recs(aaip, zero_char, 1, 1);
       }
       aaip->rec_head_missing= 2;
       aaip->rec_missing= 0;
       aaip->num_recs++;
       if(aaip->rec_ends) {
         aaip->num_components++;
         aaip->end_of_components= aaip->recs_fill;
       }
     }
     if(aaip->end_of_components != aaip->recs_fill &&
        aaip->end_of_components != 0) {
                                            /* incomplete component detected */
       /* add empty end record */
       aaip_push_to_recs(aaip, zero_char, 2, 0);
       aaip->num_recs++;
       aaip->num_components++;
       aaip->end_of_components= aaip->recs_fill;
     }
     if(!(aaip->first_is_name ^ (aaip->num_components % 2))) {
                                               /* value component is missing */
       /* add dummy component */
       aaip_push_to_recs(aaip, zero_char, 2, 0);
       aaip->num_recs++;
       aaip->num_components++;
       aaip->end_of_components= aaip->recs_fill;
     }
     aaip->aa_ends= 2;
   } else
     aaip->aa_head_missing= 5;
 }
 return(0);
}

static int aaip_consume_aa_head	(	struct aaip_state *	aaip,
		unsigned char **	data,
		size_t *	num_data,
		int	flag
	)			[static]

Definition at line 746 of file aaip_0_2.c.

References aaip_state::aa_ends, aaip_state::aa_head_missing, aaip_state::aa_missing, aaip_state::aa_name, aaip_push_to_recs(), aaip_read_from_recs(), and aaip_state::recs_fill.

Referenced by aaip_submit_data().

{
 size_t todo;
 unsigned char aa_head[5];

 todo= *num_data;
 if(todo >= aaip->aa_head_missing)
   todo= aaip->aa_head_missing;
 aaip_push_to_recs(aaip, *data, todo, 0);
 aaip->aa_head_missing-= todo;
 if(aaip->aa_head_missing == 0) {
   aaip_read_from_recs(aaip, aaip->recs_fill - 5, aa_head, 5, 0);
   if(aa_head[0] != aaip->aa_name[0] || aa_head[1] != aaip->aa_name[1] ||
      aa_head[3] != 1)
     return(-1);
   aaip->aa_missing= aa_head[2];
   aaip->aa_ends= !(aa_head[4] & 1);
   aaip->recs_fill-= 5; /* AA heads do not get delivered */
   if(aaip->aa_missing >= 5)
     aaip->aa_missing-= 5;
   else
     aaip->aa_missing= 0;
 }
 (*num_data)-= todo;
 (*data)+= todo;
 return(1);
}

static int aaip_consume_rec_data	(	struct aaip_state *	aaip,
		unsigned char **	data,
		size_t *	num_data,
		int	flag
	)			[static]

Definition at line 713 of file aaip_0_2.c.

References aaip_state::aa_missing, aaip_push_to_recs(), aaip_state::end_of_components, aaip_state::num_components, aaip_state::num_recs, aaip_state::rec_ends, aaip_state::rec_head_missing, aaip_state::rec_missing, aaip_state::recs_fill, and aaip_state::recs_invalid.

Referenced by aaip_consume_aa_data().

{
 size_t todo;
 
 todo= *num_data;
 if(todo > aaip->aa_missing)
   todo= aaip->aa_missing;
 if(todo > aaip->rec_missing)
   todo= aaip->rec_missing;
 if(!aaip->recs_invalid)
   aaip_push_to_recs(aaip, *data, todo, 1);
 aaip->rec_missing-= todo;
 aaip->aa_missing-= todo;
 (*num_data)-= todo;
 (*data)+= todo;
 if(aaip->rec_missing <= 0) {
   if(aaip->recs_invalid > 0) {
     if(aaip->rec_ends)
       aaip->recs_invalid--;
   } else {
     aaip->num_recs++;
     if(aaip->rec_ends) {
       aaip->num_components++;
       aaip->end_of_components= aaip->recs_fill;
     }
   }
   aaip->rec_head_missing= 2;
 }
 return(0);
}

static int aaip_consume_rec_head	(	struct aaip_state *	aaip,
		unsigned char **	data,
		size_t *	num_data,
		int	flag
	)			[static]

Definition at line 689 of file aaip_0_2.c.

References aaip_state::aa_missing, aaip_get_buffer_byte(), aaip_push_to_recs(), aaip_state::rec_ends, aaip_state::rec_head_missing, aaip_state::rec_missing, aaip_state::recs_fill, and aaip_state::recs_invalid.

Referenced by aaip_consume_aa_data().

{
 size_t todo;

 todo= *num_data;
 if(todo > aaip->aa_missing)
   todo= aaip->aa_missing;
 if(todo >= aaip->rec_head_missing)
   todo= aaip->rec_head_missing;
 if(!aaip->recs_invalid)
   aaip_push_to_recs(aaip, *data, todo, 0);
 aaip->rec_head_missing-= todo;
 if(aaip->rec_head_missing == 0) {
   aaip->rec_missing= aaip_get_buffer_byte(aaip, aaip->recs_fill - 1, 0); 
   aaip->rec_ends= !(aaip_get_buffer_byte(aaip, aaip->recs_fill - 2, 0) & 1);
 }
 aaip->aa_missing-= todo;
 (*num_data)-= todo;
 (*data)+= todo;
 return(1);
}

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);
}

static ssize_t aaip_encode_acl_text	(	char *	acl_text,
		size_t	result_size,
		unsigned char *	result,
		int	flag
	)			[static]

Definition at line 268 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_numeric_id(), Aaip_READ, Aaip_SWITCH_MARK, Aaip_WRITE, isoburn_imgen_opts::gid, and isoburn_imgen_opts::uid.

Referenced by aaip_encode_acl().

{
 char *rpt, *npt, *cpt;
 int qualifier= 0, perms, type, i, qualifier_len, num_recs;
 uid_t uid, huid;
 gid_t gid, hgid;
 ssize_t count= 0;
 struct passwd *pwd;
 struct group *grp;
 char name[1024];
 double num;

 if(flag & 4) {
   /* set SWITCH_MARK to indicate a default ACL */;
   if(!(flag & 1)) {
     if(count >= result_size)
       return(-1);
     result[count]= (Aaip_SWITCH_MARK << 4) | Aaip_EXEC;
   }
   count++;
 }

 for(rpt= acl_text; *rpt != 0; rpt= npt) {
   npt= strchr(rpt, '\n');
   if(npt == 0)
     npt= rpt + strlen(rpt);
   else
     npt++;
   if(*rpt == '#')
 continue;
   cpt= strchr(rpt, ':');
   if(cpt == NULL)
 continue;
   cpt= strchr(cpt + 1, ':');
   if(cpt == NULL)
 continue;
   qualifier= 0;
   if(strncmp(rpt, "user:", 5) == 0) {
     if(cpt - rpt == 5)
       type= Aaip_ACL_USER_OBJ;
     else {
       if(cpt - (rpt + 5) >= sizeof(name))
 continue;
       strncpy(name, rpt + 5, cpt - (rpt + 5)); 
       name[cpt - (rpt + 5)]= 0;
       if(flag & 2) {
         type= Aaip_ACL_USER_N;
         pwd= getpwnam(name);
         if(pwd == NULL) {
           num= aaip_numeric_id(name, 0);
           if(num <= 0)
             goto user_by_name;
           uid= huid= num;
         } else
           uid= huid= pwd->pw_uid;
         /* Convert uid into Qualifier Record */
         for(i= 0; huid != 0; i++)
           huid= huid >> 8;
         qualifier_len= i;
         for(i= 0; i < qualifier_len ; i++)
           name[i]= uid >> (8 * (qualifier_len - i - 1));
       } else {
user_by_name:;
         type= Aaip_ACL_USER;
         qualifier_len= strlen(name);
       }
       qualifier= 1;
     }
   } else if(strncmp(rpt, "group:", 6) == 0) {
     if(cpt - rpt == 6)
       type= Aaip_ACL_GROUP_OBJ;
     else {
       if(cpt - (rpt + 6) >= sizeof(name))
 continue;
       strncpy(name, rpt + 6, cpt - (rpt + 6)); 
       if(flag & 2) {
         type= Aaip_ACL_GROUP_N;
         grp= getgrnam(name);
         if(grp == NULL) {
           num= aaip_numeric_id(name, 0);
           if(num <= 0)
             goto group_by_name;
           gid= hgid= num;
         } else
           gid= hgid= grp->gr_gid;
         /* Convert gid into Qualifier Record */
         for(i= 0; hgid != 0; i++)
           hgid= hgid >> 8;
         qualifier_len= i;
         for(i= 0; i < qualifier_len ; i++)
           name[i]= gid >> (8 * (qualifier_len - i - 1));

       } else {
group_by_name:;
         type= Aaip_ACL_GROUP;
         qualifier_len= strlen(name);
       }
       qualifier= 1;
     }
   } else if(strncmp(rpt, "other:", 6) == 0) {
     type= Aaip_ACL_OTHER;
   } else if(strncmp(rpt, "mask:", 5) == 0) {
     type= Aaip_ACL_MASK;
   } else
 continue;

   if(npt - cpt < 3)
 continue;
   perms= 0;
   if(cpt[1] == 'r')
     perms|= Aaip_READ;
   if(cpt[2] == 'w')
     perms|= Aaip_WRITE;
   if(cpt[3] == 'x')
     perms|= Aaip_EXEC;

   if(!(flag & 1)) {
     if(count >= result_size)
       return(-1);
     result[count]= perms | ((!!qualifier) << 3) | (type << 4);
   }
   count++;

   if(qualifier) {
     num_recs= (qualifier_len / 127) + !!(qualifier_len % 127);
     if(!(flag & 1)) {
       if(count + 1 > result_size)
         return(-1);
       for(i= 0; i < num_recs; i++) {
         if(i < num_recs - 1)
           result[count++]= 255;
         else {
           result[count++]= (qualifier_len % 127);
           if(result[count - 1] == 0)
             result[count - 1]= 127;
         }
         if(count + (result[count - 1] & 127) > result_size)
           return(-1);
         memcpy(result + count, name + i * 127, result[count - 1] & 127);
         count+= result[count - 1] & 127;
       }
     } else
       count+= qualifier_len + num_recs;
   }
 }

 return(count);
}

static void aaip_encode_byte	(	unsigned char *	result,
		size_t *	result_fill,
		unsigned char	value
	)			[static]

Definition at line 137 of file aaip_0_2.c.

Referenced by aaip_encode_comp().

{
 result[(*result_fill / 250) * 255 + 5 + (*result_fill % 250)]= value;
 (*result_fill)++;
}

static int aaip_encode_comp	(	unsigned char *	result,
		size_t *	result_fill,
		char *	data,
		size_t	l,
		int	flag
	)			[static]

Definition at line 145 of file aaip_0_2.c.

References aaip_encode_byte().

Referenced by aaip_encode_pair().

{
 size_t todo;
 char *rpt, *comp_start;

 if(l == 0) {
   aaip_encode_byte(result, result_fill, 0);
   aaip_encode_byte(result, result_fill, 0);
   return(1);
 }
 for(rpt= data; rpt - data < l;) {
   todo= l - (rpt - data);
   aaip_encode_byte(result, result_fill, (todo > 255));
   if(todo > 255)
     todo= 255;
   aaip_encode_byte(result, result_fill, todo);
   for(comp_start= rpt; rpt - comp_start < todo; rpt++)
     aaip_encode_byte(result, result_fill, *((unsigned char *) rpt));
 }
 return(1);
}

static int aaip_encode_pair	(	char *	name,
		size_t	attr_length,
		char *	attr,
		unsigned int *	num_recs,
		size_t *	comp_size,
		unsigned char *	result,
		size_t	result_fill,
		int	flag
	)			[static]

Definition at line 173 of file aaip_0_2.c.

References aaip_encode_comp().

Referenced by aaip_encode().

{
 size_t l;

 l= strlen(name);
 *num_recs= l / 255 + (!!(l % 255)) + (l == 0) +
            attr_length / 255 + (!!(attr_length % 255)) + (attr_length == 0);
 *comp_size= l + attr_length + 2 * *num_recs;

 if(flag & 1)
   return(1);

 aaip_encode_comp(result, &result_fill, name, l, 0);
 aaip_encode_comp(result, &result_fill, attr, attr_length, 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);
}

static int aaip_get_buffer_byte	(	struct aaip_state *	aaip,
		size_t	idx,
		int	flag
	)			[static]

Definition at line 597 of file aaip_0_2.c.

References aaip_ring_adr().

Referenced by aaip_consume_rec_head(), and aaip_fetch_data().

{
 unsigned char *start_pt;
 size_t at_start_pt, at_recs;

 aaip_ring_adr(aaip, idx, 1,
               &start_pt, &at_start_pt, &at_recs, 0);
 return((int) *start_pt);
}

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);
}

static double aaip_numeric_id	(	char *	name,
		int	flag
	)			[static]

Definition at line 243 of file aaip_0_2.c.

Referenced by aaip_encode_acl_text().

{
 double num;
 char *cpt;

 for(cpt= name; *cpt != 0; cpt++)
   if(*cpt < '0' || *cpt >'9')
 break;
 if(*cpt != 0)
   return(-1);
 sscanf(name, "%lf", &num);
 return(num);
}

static int aaip_push_to_recs	(	struct aaip_state *	aaip,
		unsigned char *	data,
		size_t	todo,
		int	flag
	)			[static]

Definition at line 549 of file aaip_0_2.c.

References aaip_ring_adr(), aaip_state::ready_bytes, aaip_state::recs, and aaip_state::recs_fill.

Referenced by aaip_consume_aa_data(), aaip_consume_aa_head(), aaip_consume_rec_data(), and aaip_consume_rec_head().

{
 unsigned char *start_pt;
 size_t at_start_pt, at_recs;

 aaip_ring_adr(aaip, aaip->recs_fill, todo,
               &start_pt, &at_start_pt, &at_recs, 0);
 if(at_start_pt > 0)
   memcpy(start_pt,  data, at_start_pt);
 if(at_recs > 0)
   memcpy(aaip->recs, data + at_start_pt, at_recs);
 aaip->recs_fill+= todo;
 if(flag &  1)
   aaip->ready_bytes+= todo;
 return(1);
}

static int aaip_read_from_recs	(	struct aaip_state *	aaip,
		size_t	idx,
		unsigned char *	data,
		size_t	num_data,
		int	flag
	)			[static]

Definition at line 568 of file aaip_0_2.c.

References aaip_ring_adr(), and aaip_state::recs.

Referenced by aaip_consume_aa_head(), and aaip_fetch_data().

{
 unsigned char *start_pt;
 size_t at_start_pt, at_recs;

 aaip_ring_adr(aaip, idx, num_data,
               &start_pt, &at_start_pt, &at_recs, 0);
 if(at_start_pt > 0)
   memcpy(data, start_pt, at_start_pt);
 if(at_recs > 0)
   memcpy(data + at_start_pt, aaip->recs, at_recs);
 return(1);
}

static int aaip_read_qualifier	(	unsigned char *	data,
		size_t	num_data,
		char *	name,
		size_t	name_size,
		size_t *	name_fill,
		int	flag
	)			[static]

Definition at line 1188 of file aaip_0_2.c.

Referenced by aaip_decode_acl().

{
 int is_done= 0, rec_len= 0;
 unsigned char *rpt;

 *name_fill= 0;
 for(rpt= data; !is_done; rpt+= rec_len) {
   rec_len= (*rpt) & 127;
   is_done= !((*rpt) & 128);
   if(*name_fill + rec_len >= name_size || rpt + 1 + rec_len - data > num_data)
     return(-1);
   memcpy(name + *name_fill, rpt + 1, rec_len);
   rpt+= 1 + rec_len;
   (*name_fill)+= rec_len;
   name[*name_fill]= 0;
 }
 return(1);
}

static int aaip_ring_adr	(	struct aaip_state *	aaip,
		size_t	idx,
		size_t	todo,
		unsigned char **	start_pt,
		size_t *	at_start_pt,
		size_t *	at_recs,
		int	flag
	)			[static]

Definition at line 521 of file aaip_0_2.c.

References Aaip_buffer_reservE, Aaip_buffer_sizE, aaip_state::recs, and aaip_state::recs_start.

Referenced by aaip_get_buffer_byte(), aaip_push_to_recs(), aaip_read_from_recs(), aaip_set_buffer_byte(), and aaip_shift_recs().

{
 size_t ahead;

 ahead= Aaip_buffer_sizE + Aaip_buffer_reservE
        - (aaip->recs_start - aaip->recs);
 if(idx < ahead)
   *start_pt= (aaip->recs_start + idx);
 else
   *start_pt= aaip->recs + (idx - ahead);
 ahead= Aaip_buffer_sizE + Aaip_buffer_reservE - (*start_pt - aaip->recs);
 if(todo >= ahead) {
   *at_start_pt= ahead;
   *at_recs= todo - ahead;
   return(2);
 }
 *at_start_pt= todo;
 *at_recs= 0;
 return(1);
}

static int aaip_set_buffer_byte	(	struct aaip_state *	aaip,
		size_t	idx,
		unsigned char	data,
		int	flag
	)			[static]

Definition at line 584 of file aaip_0_2.c.

References aaip_ring_adr().

Referenced by aaip_consume_aa_data().

{
 unsigned char *start_pt;
 size_t at_start_pt, at_recs;

 aaip_ring_adr(aaip, idx, 1,
               &start_pt, &at_start_pt, &at_recs, 0);
 *start_pt= data;
 return(1);
}

static int aaip_shift_recs	(	struct aaip_state *	aaip,
		size_t	todo,
		int	flag
	)			[static]

Definition at line 608 of file aaip_0_2.c.

References aaip_ring_adr(), aaip_state::end_of_components, aaip_state::recs, aaip_state::recs_fill, and aaip_state::recs_start.

Referenced by aaip_fetch_data().

{
 int ret;
 unsigned char *start_pt;
 size_t at_start_pt, at_recs;

 if(todo < aaip->recs_fill) {
   ret= aaip_ring_adr(aaip, 0, todo, &start_pt, &at_start_pt, &at_recs, 0);
   if(ret == 1)
     aaip->recs_start= start_pt + todo;
   else
     aaip->recs_start= aaip->recs + at_recs;
 } else {
   aaip->recs_start= aaip->recs;
 }
 aaip->recs_fill-= todo;
 if(aaip->end_of_components >= todo)
   aaip->end_of_components-= todo;
 else
   aaip->end_of_components= 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);
}

static int aaip_write_acl_line	(	char **	result,
		size_t *	result_size,
		char *	tag_type,
		char *	qualifier,
		char *	permissions,
		int	flag
	)			[static]

Definition at line 1159 of file aaip_0_2.c.

Referenced by aaip_decode_acl().

{
 size_t needed, tag_len, perm_len, qualifier_len;

 tag_len= strlen(tag_type);
 qualifier_len= strlen(qualifier);
 perm_len= strlen(permissions);
 needed= tag_len + qualifier_len + perm_len + 3;
 if((flag & 1)) {
   (*result_size)+= needed;
   return(1);
 }
 if(needed + 1 > *result_size) /* +1 : want to append a trailing 0 */
   return(-1);
 memcpy((*result), tag_type, tag_len);
 (*result)[tag_len]= ':';
 memcpy((*result) + tag_len + 1, qualifier, qualifier_len);
 (*result)[tag_len + 1 + qualifier_len]= ':';
 memcpy((*result) + tag_len + 1 + qualifier_len + 1, permissions, perm_len);
 (*result)[tag_len + 1 + qualifier_len + 1 + perm_len]= '\n';
 (*result)[tag_len + 1 + qualifier_len + 1 + perm_len + 1] = 0;
 (*result)+= needed;
 (*result_size)-= needed;
 return(1);
}