00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include <ctype.h>
00021 #include <sys/types.h>
00022 #include <unistd.h>
00023 #include <stdlib.h>
00024 #include <string.h>
00025 #include <stdio.h>
00026 #include <errno.h>
00027
00028 #include <sys/acl.h>
00029
00030 #include "aaip_0_2.h"
00031
00032 #define Aaip_test_name_sizE 1024
00033 #define Aaip_test_value_sizE 1024
00034
00035
00036 static int print_result(unsigned char *result, size_t result_len, int flag)
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 }
00058
00059
00060 static int decode_acl(unsigned char *result, size_t result_len,
00061 char *out_path, int flag)
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 }
00114
00115
00116 static int test_acl(char *in_path, char *out_path, int flag)
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 }
00169
00170 int main(int argc, char **argv)
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 }
00304
00305
