legacy/libisoburn/trunk/test/aaip_0_2_test.c

444 lines
12 KiB
C
Raw Normal View History

/*
Arbitrary Attribute Interchange Protocol , AAIP version 0.2
Demonstration program for encoding and decoding EA and ACL.
See http://libburnia-project.org/wiki/AAIP
test/aaip_0_2_test.c - Main program for test binary
Compile:
cc -g -Wall -o test/aaip test/aaip_0_2.c test/aaip_0_2_test.c -lacl
Usage: ./aaip name value
Long parameters ./aaip -name"x100" -value"x100"
>>> ACLs
*/
#include <ctype.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
2008-12-25 14:01:36 +00:00
#include <errno.h>
#include <sys/acl.h>
#include "aaip_0_2.h"
#define Aaip_test_name_sizE 1024
#define Aaip_test_value_sizE 1024
2008-12-25 14:01:36 +00:00
static int print_result(unsigned char *result, size_t result_len, int flag)
{
int i;
printf(
" - - - - - - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - - 6 - - 7 - - 8 - - 9\n");
printf("\n");
printf("%4u : ", 0);
for(i= 0; i < result_len; i++) {
if(result[i] >= 32 && result[i] <= 126)
printf("'%c' ", result[i]);
else
printf("%3u ", (unsigned int) ((unsigned char *) result)[i]);
if((i % 10) == 9)
printf("\n%4u : ", (unsigned int) (i + 1));
}
printf("\n\n");
printf(
" - - - - - - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - - 6 - - 7 - - 8 - - 9\n");
printf("\n");
return(1);
}
static int print_attrs(size_t num_attrs, char **names, size_t *value_lengths,
char **values, int flag)
{
size_t i, j;
for(i= 0; i < num_attrs; i++) {
printf("name='");
for(j= 0; names[i][j] != 0; j++) {
if(names[i][j] >= 32 && names[i][j] <= 126 &&
names[i][j] != '\\' && names[i][j] != '\'')
printf("%c", names[i][j]);
else
printf("\\%o", (unsigned int) ((unsigned char **) names)[i][j]);
}
printf("' (%d)\n", (int) j);
printf("value='");
for(j= 0; j < value_lengths[i]; j++) {
if(values[i][j] >= 32 && values[i][j] <= 126 &&
values[i][j] != '\\' && values[i][j] != '\'')
printf("%c", values[i][j]);
else
printf("\\%3.3o", (unsigned int) ((unsigned char **) values)[i][j]);
}
printf("' (%d)\n\n", (int) j);
}
return(1);
}
static int do_touch(char *path, int flag)
{
FILE *fp;
fp= fopen(path, "a");
if(fp == NULL) {
fprintf(stderr, "fopen(\"%s\") failed: %d %s\n",
path, errno, errno != 0 ? strerror(errno) : "");
return(0);
}
fclose(fp);
return(1);
}
2008-12-26 12:40:04 +00:00
static int decode_acl(unsigned char *result, size_t result_len,
char *out_path, int flag)
{
int ret;
size_t consumed, text_fill;
char *text= NULL;
ret= aaip_decode_acl(result, result_len, &consumed, NULL, 0, &text_fill, 1);
if(ret <= 0) {
fprintf(stderr, "aaip_decode_acl(,1) failed: ret= %d\n", ret);
ret= 0; goto ex;
}
text= calloc(text_fill, 1);
ret= aaip_decode_acl(result, result_len, &consumed, text, text_fill,
&text_fill, 0);
if(ret <= 0) {
fprintf(stderr, "aaip_decode_acl(,0) failed: ret= %d\n", ret);
ret= 0; goto ex;
}
printf("--- ret= %d , text=\n%s--- end of text\n\n", ret, text);
if(out_path == NULL)
{ret= 1; goto ex;}
ret= do_touch(out_path, 0);
if(ret <= 0)
goto ex;
ret= aaip_set_acl_text(out_path, text, 0);
if(ret <= 0) {
fprintf(stderr, "aaip_set_acl_text() failed");
if(ret == -1)
fprintf(stderr, ": %d %s\n", errno, errno != 0 ? strerror(errno) : "");
else
fprintf(stderr, "\n");
2008-12-26 12:40:04 +00:00
ret= 0; goto ex;
}
ret= 1;
ex:
if(text != NULL)
free(text);
return(ret);
}
static int test_acl(char *in_path, char *out_path, int flag)
2008-12-25 14:01:36 +00:00
{
int ret;
char *acl_text= NULL;
unsigned char *result= NULL;
size_t result_len;
ret= aaip_get_acl_text(in_path, &acl_text, 0);
if(ret <= 0) {
fprintf(stderr, "aaip_get_acl_text() failed");
if(ret == -1)
fprintf(stderr, ": %d %s\n", errno, errno != 0 ? strerror(errno) : "");
else
fprintf(stderr, "\n");
ret= 6; goto ex;
2008-12-25 14:01:36 +00:00
}
printf("--- ACL:\n%s--- end of ACL\n\n", acl_text);
2008-12-26 12:40:04 +00:00
2008-12-25 14:01:36 +00:00
ret= aaip_encode_acl(acl_text, &result_len, &result, 0);
if(ret <= 0) {
fprintf(stderr, "aaip_encode_acl(text) failed: ret= %d\n", ret);
ret= 7; goto ex;
2008-12-25 14:01:36 +00:00
}
print_result(result, result_len, 0);
2008-12-26 12:40:04 +00:00
ret= decode_acl(result, result_len, out_path, 0);
if(ret <= 0)
{ret= 8; goto ex;}
2008-12-25 14:01:36 +00:00
free(result); result= NULL;
2008-12-26 12:40:04 +00:00
2008-12-25 14:01:36 +00:00
ret= aaip_encode_acl(acl_text, &result_len, &result, 2);
if(ret <= 0) {
fprintf(stderr, "aaip_encode_acl(num) failed: ret= %d\n", ret);
ret= 9; goto ex;
2008-12-25 14:01:36 +00:00
}
print_result(result, result_len, 0);
2008-12-26 12:40:04 +00:00
ret= decode_acl(result, result_len, out_path, 0);
if(ret <= 0)
{ret= 10; goto ex;}
2008-12-25 14:01:36 +00:00
ret= 0;
2008-12-25 14:01:36 +00:00
ex:;
aaip_get_acl_text("", &acl_text, 1 << 15);
2008-12-25 14:01:36 +00:00
if(result != NULL)
free(result);
return(ret);
}
int synthetic_pairs(char *prog, int argc, char **argv, int flag)
{
int ret, l, mult= 0, k;
size_t result_len, i;
unsigned char *result= NULL;
char **names= NULL, **values= NULL, *cpt, **param;
size_t *value_lengths= NULL;
struct aaip_state *aaip;
size_t consumed= 0;
char name[Aaip_test_name_sizE + 1];
size_t name_fill;
char value[Aaip_test_value_sizE + 1];
size_t value_fill;
size_t todo;
int submit_data, is_done;
unsigned char *rpt;
unsigned int skipped, was_skipped= 0;
aaip= (struct aaip_state *) calloc(aaip_sizeof_aaip_state(), 1);
names= calloc(sizeof(char *), argc / 2);
values= calloc(sizeof(char *), argc / 2);
value_lengths= calloc(sizeof(size_t), argc / 2);
for(i= 0; i < argc; i++) {
if(i % 2)
param= values + i / 2;
else
param= names + i / 2;
(*param)= argv[i];
if(argv[i][0] == '-') {
cpt= strchr(argv[i], 'x');
if(cpt != NULL) {
l= cpt - argv[i] - 1;
if(l > 0)
sscanf(cpt + 1, "%d", &mult);
if(l > 0 && mult > 0) {
(*param)= calloc(1, l * mult + 1);
if((*param) != NULL) {
for(k= 0; k < mult; k++)
memcpy((*param) + k * l, argv[i] + 1, l);
(*param)[mult * l]= 0;
} else
(*param)= argv[i];
}
}
}
if(i % 2)
value_lengths[i / 2]= strlen(values[i / 2]);
}
ret= aaip_encode("AA", (unsigned int) (argc / 2), names,
value_lengths, values,
&result_len, &result, 0);
if(ret <= 0) {
fprintf(stderr, "%s : aaip_encode failed with ret= %d\n", prog, ret);
return(2);
}
2008-12-25 14:01:36 +00:00
print_result(result, result_len, 0);
aaip_init_aaip_state(aaip, "AA", 0);
rpt= result;
submit_data= 1;
is_done= 0;
while(!is_done) {
if(submit_data) {
todo= result_len - (rpt - result);
if(todo > 2048)
todo= 2048;
if(todo == 0) {
fprintf(stderr, "%s : Out of data while still prompted to submit\n",
prog);
return(5);
}
} else
todo= 0;
ret= aaip_decode_pair(aaip, rpt, todo, &consumed,
name, Aaip_test_name_sizE, &name_fill,
value, Aaip_test_value_sizE, &value_fill, 0);
skipped= aaip_get_pairs_skipped(aaip, 0);
if(skipped > was_skipped) {
printf("- skipped %d pair%s -\n\n", skipped - was_skipped,
skipped - was_skipped > 1 ? "s" : "");
was_skipped= skipped;
}
if(ret < 0) {
fprintf(stderr, "%s : aaip_decode_pair failed with ret= %d\n", prog, ret);
return(3);
}
rpt+= todo;
if(ret == 0) {
rpt-= todo;
submit_data= 0;
continue;
} else if(ret == 1) {
submit_data= 1;
continue;
} else if(ret == 2) {
submit_data= 1;
} else if(ret == 3) {
submit_data= 0;
} else if(ret == 4) {
is_done= 1;
} else if(ret == 5) {
is_done= 1;
break;
} else {
fprintf(stderr, "%s : Unknown return %d from aaip_decode_pair()\n",
prog, ret);
return(4);
}
name[name_fill]= 0;
value[value_fill]= 0;
if((name_fill < 1000 && value_fill < 1000)) {
printf("name = '%s' (%lu)\n", name, (unsigned long) name_fill);
printf("value= '%s' (%lu)\n", value, (unsigned long) value_fill);
} else {
printf("name = (%lu)\n", (unsigned long) name_fill);
printf("value= (%lu)\n", (unsigned long) value_fill);
}
printf("\n");
}
return(0);
}
/*
@param flag bit0= use numeric qualifiers
*/
static int copy_all(char *in_path, char *out_path, int flag)
{
int ret;
struct aaip_state *aaip= NULL;
size_t in_num_attrs, *in_value_lengths= NULL;
char **in_names= NULL, **in_values= NULL;
int is_done= 0, first_round= 1;
unsigned char *result= NULL, *rpt;
size_t result_len, todo, consumed;
size_t out_num_attrs, *out_value_lengths= NULL;
char **out_names= NULL, **out_values= NULL;
ret= aaip_get_attr_list(in_path, &in_num_attrs, &in_names, &in_value_lengths,
&in_values, 1 | ((flag & 1) << 1));
if(ret <= 0)
{ret= 11; goto ex;}
print_attrs(in_num_attrs, in_names, in_value_lengths, in_values, 0);
ret= aaip_encode("AA", (unsigned int) in_num_attrs, in_names,
in_value_lengths, in_values, &result_len, &result, 0);
if(ret == 0)
{ret= 12; goto ex;}
if(result_len <= 0) {
fprintf(stderr, "No result\n");
ret= 13; goto ex;
}
print_result(result, result_len, 0);
rpt= result;
while(!is_done) {
todo= result_len - (rpt - result);
if(todo > 2048)
todo= 2048;
if(todo == 0) {
fprintf(stderr, "Out of data while still prompted to submit\n");
ret= 14; goto ex;
}
/* Allow 1 million bytes of memory consumption, 100,000 attributes */
ret= aaip_decode_attrs(&aaip, "AA", (size_t) 1000000, (size_t) 100000,
rpt, todo, &consumed, first_round);
rpt+= consumed;
first_round= 0;
if(ret == 1)
continue;
if(ret == 2)
break;
fprintf(stderr, "aaip_decode_attrs() returns %d\n", ret);
ret= 15; goto ex;
}
if(rpt - result != result_len) {
fprintf(stderr, "aaip_decode_attrs() returns 2 but %d bytes are left\n",
(int) (result_len - (rpt - result)));
ret= 16; goto ex;
}
ret= aaip_get_decoded_attrs(&aaip, &out_num_attrs, &out_names,
&out_value_lengths, &out_values, 0);
if(ret != 1) {
fprintf(stderr, "aaip_get_decoded_attrs() returns %d\n", ret);
ret= 17; goto ex;
}
print_attrs(out_num_attrs, out_names, out_value_lengths, out_values, 0);
ret= do_touch(out_path, 0);
if(ret <= 0)
{ret= 19; goto ex;}
ret= aaip_set_attr_list(out_path, out_num_attrs, out_names, out_value_lengths,
out_values, 1 | 2);
if(ret != 1) {
fprintf(stderr, "aaip_set_attr_list() returns %d\n", ret);
ret= 18; goto ex;
}
ret= 0;
ex:;
if(in_names != NULL || in_value_lengths != NULL || in_values != NULL)
aaip_get_attr_list(in_path, &in_num_attrs, &in_names, &in_value_lengths,
&in_values, 1 << 15);
if(out_names != NULL || out_value_lengths != NULL || out_values != NULL)
aaip_get_decoded_attrs(&aaip, &out_num_attrs, &out_names,
&out_value_lengths, &out_values, 15);
aaip_decode_attrs(&aaip, "AA", (size_t) 0, (size_t) 0, NULL, (size_t) 0,
&consumed, 1 << 15);
return(ret);
}
int main(int argc, char **argv)
{
int ret;
if(argc < 2) {
usage:
fprintf(stderr, "usage : %s options\n", argv[0]);
fprintf(stderr, " -pairs [-]name[xNNN] [-]value[xNNN] [...]\n");
fprintf(stderr, " -copy_acl source_path target_path\n");
fprintf(stderr, " -copy source_path target_path\n");
exit(1);
}
if(strcmp(argv[1], "-pairs") == 0) {
if(argc < 4 || (argc % 2) != 0)
goto usage;
ret= synthetic_pairs(argv[0], argc - 2, argv + 2, 0);
} else if(strcmp(argv[1], "-copy_acl") == 0) {
if(argc != 4)
goto usage;
ret= test_acl(argv[2], argv[3], 0);
} else if(strcmp(argv[1], "-copy") == 0) {
if(argc != 4)
goto usage;
ret= copy_all(argv[2], argv[3], 1);
} else
goto usage;
exit(ret);
}