trunk/test/aaip_0_2_test.c File Reference

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

Include dependency graph for aaip_0_2_test.c:

Go to the source code of this file.

Defines

#define Aaip_test_name_sizE 1024

#define Aaip_test_value_sizE 1024

Functions

static int print_result (unsigned char *result, size_t result_len, int flag)

static int decode_acl (unsigned char *result, size_t result_len, char *out_path, int flag)

static int test_acl (char *in_path, char *out_path, int flag)

int main (int argc, char **argv)

Define Documentation

#define Aaip_test_name_sizE 1024

Definition at line 32 of file aaip_0_2_test.c.

Referenced by main().

#define Aaip_test_value_sizE 1024

Definition at line 33 of file aaip_0_2_test.c.

Referenced by main().

Function Documentation

static int decode_acl	(	unsigned char *	result,
		size_t	result_len,
		char *	out_path,
		int	flag
	)			`[static]`

Definition at line 60 of file aaip_0_2_test.c.

References aaip_decode_acl().

Referenced by test_acl().

00062 {
00063  int ret;
00064  size_t consumed, text_fill;
00065  char *text= NULL;
00066  acl_t out_acl= NULL;
00067  FILE *fp;
00068 
00069  ret= aaip_decode_acl(result, result_len, &consumed, NULL, 0, &text_fill, 1);
00070  if(ret <= 0) {
00071    fprintf(stderr, "aaip_decode_acl(,1) failed: ret= %d\n", ret);
00072    ret= 0; goto ex;
00073  }
00074  text= calloc(text_fill, 1);
00075  ret= aaip_decode_acl(result, result_len, &consumed, text, text_fill,
00076                       &text_fill, 0);
00077  if(ret <= 0) {
00078    fprintf(stderr, "aaip_decode_acl(,0) failed: ret= %d\n", ret);
00079    ret= 0; goto ex;
00080  }
00081  printf("--- ret= %d , text=\n%s--- end of text\n\n", ret, text);
00082 
00083  if(out_path == NULL)
00084    {ret= 1; goto ex;}
00085 
00086  out_acl= acl_from_text(text);
00087  if(out_acl == NULL) {
00088    fprintf(stderr, "acl_from_text failed: %d  %s\n",
00089            errno, errno != 0 ? strerror(errno) : "");
00090    ret= 0; goto ex;
00091  }
00092  fp= fopen(out_path, "a");
00093  if(fp == NULL) {
00094    fprintf(stderr, "fopen(\"%s\") failed: %d  %s\n",
00095            out_path, errno, errno != 0 ? strerror(errno) : "");
00096    ret= 0; goto ex;
00097  }
00098  fclose(fp);
00099  
00100  ret= acl_set_file(out_path, ACL_TYPE_ACCESS, out_acl);
00101  if(ret == -1) {
00102    fprintf(stderr, "acl_set_file(\"%s\") failed: %d  %s\n",
00103            out_path, errno, errno != 0 ? strerror(errno) : "");
00104    ret= 0; goto ex;
00105  } 
00106  ret= 1;
00107 ex:
00108  if(out_acl != NULL)
00109    acl_free(out_acl);
00110  if(text != NULL)
00111    free(text);
00112  return(ret);
00113 }

int main	(	int	argc,
		char **	argv
	)

Definition at line 170 of file aaip_0_2_test.c.

References aaip_decode_pair(), aaip_encode(), aaip_get_pairs_skipped(), aaip_init(), aaip_sizeof_aaip_state(), Aaip_test_name_sizE, Aaip_test_value_sizE, print_result(), and test_acl().

00171 {
00172  int  ret, l, mult= 0, k;
00173  size_t result_len, i;
00174  unsigned char *result= NULL;
00175  char **names= NULL, **values= NULL, *cpt, **param;
00176  size_t *value_lengths= NULL;
00177 
00178  struct aaip_state *aaip;
00179  size_t consumed= 0;
00180  char name[Aaip_test_name_sizE + 1];
00181  size_t name_fill;
00182  char value[Aaip_test_value_sizE + 1];
00183  size_t value_fill;
00184  size_t todo;
00185  int submit_data, is_done;
00186  unsigned char *rpt;
00187  unsigned int skipped, was_skipped= 0;
00188 
00189 
00190  test_acl("/u/test/acl", "/u/test/out_acl", 0);
00191  
00192 
00193  if(argc < 3 || (argc % 2) == 0) {
00194    fprintf(stderr, "usage: %s [-]name[xNNN] [-]value[xNNN] ...\n", argv[0]);
00195    exit(1);
00196  }
00197  aaip= (struct aaip_state *) calloc(aaip_sizeof_aaip_state(), 1);
00198  names= calloc(sizeof(char *), (argc - 1) / 2);
00199  values= calloc(sizeof(char *), (argc - 1) / 2);
00200  value_lengths= calloc(sizeof(size_t), (argc - 1) / 2);
00201  
00202  for(i= 0; i < argc - 1; i++) {
00203    if(i % 2)
00204      param= values + i / 2;
00205    else
00206      param= names + i / 2;
00207    (*param)= argv[i + 1];
00208    if(argv[i + 1][0] == '-') {
00209      cpt= strchr(argv[i + 1], 'x');
00210      if(cpt != NULL) {
00211        l= cpt - argv[i + 1] - 1;
00212        if(l > 0)
00213          sscanf(cpt + 1, "%d", &mult);
00214        if(l > 0 && mult > 0) {
00215          (*param)= calloc(1, l * mult + 1);
00216          if((*param) != NULL) {
00217            for(k= 0; k < mult; k++)
00218              memcpy((*param) + k * l, argv[i + 1] + 1, l);
00219            (*param)[mult * l]= 0;
00220          } else
00221            (*param)= argv[i + 1];
00222        }
00223      }
00224    }
00225    if(i % 2)
00226      value_lengths[i / 2]= strlen(values[i / 2]);
00227  }
00228 
00229  ret= aaip_encode("AA", (unsigned int) ((argc - 1) / 2), names,
00230                   value_lengths, values, 
00231                   &result_len, &result, 0);
00232  if(ret <= 0) {
00233    fprintf(stderr, "%s : aaip_encode failed with ret= %d\n", argv[0], ret);
00234    exit(2);
00235  }
00236  print_result(result, result_len, 0);
00237 
00238  aaip_init(aaip, "AA", 0);
00239  rpt= result;
00240  submit_data= 1;
00241  is_done= 0;
00242  while(!is_done) {
00243    if(submit_data) {
00244      todo= result_len - (rpt - result);
00245      if(todo > 2048) 
00246        todo= 2048;
00247      if(todo == 0) {
00248        fprintf(stderr, "%s : Out of data while still prompted to submit\n",
00249                argv[0]);
00250        exit(5);
00251      }
00252    } else
00253      todo= 0;
00254    ret= aaip_decode_pair(aaip, rpt, todo, &consumed,
00255                          name, Aaip_test_name_sizE, &name_fill,
00256                          value, Aaip_test_value_sizE, &value_fill, 0);
00257    skipped= aaip_get_pairs_skipped(aaip, 0);
00258    if(skipped > was_skipped) {
00259      printf("- skipped %d pair%s -\n\n", skipped - was_skipped,
00260             skipped - was_skipped > 1 ? "s" : "");
00261      was_skipped= skipped;
00262    }
00263    if(ret < 0) {
00264      fprintf(stderr, "%s : aaip_decode_pair failed with ret= %d\n",
00265              argv[0], ret);
00266      exit(3);
00267    }
00268    rpt+= todo;
00269    if(ret == 0) {
00270      rpt-= todo;
00271      submit_data= 0;
00272  continue;
00273    } else if(ret == 1) {
00274      submit_data= 1;
00275  continue;
00276    } else if(ret == 2) {
00277      submit_data= 1;
00278    } else if(ret == 3) {
00279      submit_data= 0;
00280    } else if(ret == 4) {
00281      is_done= 1;
00282    } else if(ret == 5) {
00283      is_done= 1;
00284  break;
00285    } else {
00286      fprintf(stderr, "%s : Unknown return %d from aaip_decode_pair()\n",
00287              argv[0], ret);
00288      exit(4);
00289    }
00290    name[name_fill]= 0;
00291    value[value_fill]= 0;
00292    if((name_fill < 1000 && value_fill < 1000)) {
00293      printf("name = '%s' (%lu)\n", name, (unsigned long) name_fill);
00294      printf("value= '%s' (%lu)\n", value, (unsigned long) value_fill);
00295    } else {
00296      printf("name = (%lu)\n", (unsigned long) name_fill);
00297      printf("value= (%lu)\n", (unsigned long) value_fill);
00298    }
00299    printf("\n");
00300  }
00301 
00302  exit(0);
00303 }

static int print_result	(	unsigned char *	result,
		size_t	result_len,
		int	flag
	)			`[static]`

Definition at line 36 of file aaip_0_2_test.c.

Referenced by main(), and test_acl().

00037 {
00038  int i;
00039 
00040  printf(
00041      " - - - - - - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - - 6 - - 7 - - 8 - - 9\n");
00042  printf("\n");
00043  printf("%4u :     ", 0);
00044  for(i= 0; i < result_len; i++) {
00045    if(result[i] >= 32 && result[i] <= 126)
00046      printf("'%c'   ", result[i]);
00047    else
00048      printf("%3u   ", (unsigned int) ((unsigned char *) result)[i]);
00049    if((i % 10) == 9)
00050      printf("\n%4u :     ", (unsigned int) (i + 1));
00051  }
00052  printf("\n\n");
00053  printf(
00054      " - - - - - - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - - 6 - - 7 - - 8 - - 9\n");
00055  printf("\n");
00056  return(1);
00057 }

static int test_acl	(	char *	in_path,
		char *	out_path,
		int	flag
	)			`[static]`

Definition at line 116 of file aaip_0_2_test.c.

References aaip_encode_acl(), decode_acl(), and print_result().

Referenced by main().

00117 {
00118  int ret;
00119  acl_t acl= NULL;
00120  char *acl_text= NULL;
00121  unsigned char *result= NULL;
00122  size_t result_len;
00123 
00124  acl= acl_get_file(in_path, ACL_TYPE_ACCESS);
00125  if(acl == NULL) {
00126    fprintf(stderr, "acl_get_file failed: %d  %s\n",
00127            errno, errno != 0 ? strerror(errno) : "");
00128    ret= 0; goto ex;
00129  }
00130  acl_text= acl_to_text(acl, NULL);
00131  if(acl_text  == NULL) {
00132    fprintf(stderr, "acl_to_text failed: %d  %s\n",
00133            errno, errno != 0 ? strerror(errno) : "");
00134    ret= 0; goto ex;
00135  }
00136  printf("--- ACL:\n%s--- end of ACL\n\n", acl_text);
00137 
00138  ret= aaip_encode_acl(acl_text, &result_len, &result, 0);
00139  if(ret <= 0) {
00140    fprintf(stderr, "aaip_encode_acl(text) failed: ret= %d\n", ret);
00141    ret= 0; goto ex;
00142  }
00143  print_result(result, result_len, 0);
00144  ret= decode_acl(result, result_len, out_path, 0);
00145  if(ret <= 0)
00146    goto ex;
00147  free(result); result= NULL;
00148 
00149  ret= aaip_encode_acl(acl_text, &result_len, &result, 2);
00150  if(ret <= 0) {
00151    fprintf(stderr, "aaip_encode_acl(num) failed: ret= %d\n", ret);
00152    ret= 0; goto ex;
00153  }
00154  print_result(result, result_len, 0);
00155  ret= decode_acl(result, result_len, out_path, 0);
00156  if(ret <= 0)
00157    goto ex;
00158 
00159  ret= 1;
00160 ex:;
00161  if(acl_text != NULL)
00162    acl_free(acl_text);
00163  if(acl != NULL)
00164    acl_free(acl);
00165  if(result != NULL)
00166    free(result);
00167  return(ret);
00168 }


Defines
#define	Aaip_test_name_sizE 1024
#define	Aaip_test_value_sizE 1024
Functions
static int	print_result (unsigned char *result, size_t result_len, int flag)
static int	decode_acl (unsigned char result, size_t result_len, char out_path, int flag)
static int	test_acl (char in_path, char out_path, int flag)
int	main (int argc, char **argv)