93ebd23faddba6d0ce7595ab21162895c644322a
[xfstests-dev.git] / dmapi / src / suite2 / src / test_fileattr.c
1 /*
2  * Copyright (c) 2000-2001 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #include <sys/types.h>
20 #include <sys/stat.h>
21
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <strings.h>
26
27 #include <lib/dmport.h>
28 #include <lib/hsm.h>
29 #include <lib/errtest.h>
30
31 #include <unistd.h>
32
33 #include <time.h>
34 #include <string.h>
35
36
37 /*---------------------------------------------------------------------------
38 Automated test of the DMAPI functions:
39    dm_set_fileattr()
40    dm_get_fileattr()
41    dm_get_bulkattr()
42    dm_get_dirattrs()
43
44 The command line is:
45    test_fileattr [-s sid] [-n num_files] [-v] ls_path pathname
46
47 where:
48    sid
49       is the session ID whose events you you are interested in.
50    num_files
51       is the number of test files to create.
52    ls_path
53       is the path to a copy of ls, which will be copied as a test file.
54    pathname
55       is the filesystem to use for the test.
56 ----------------------------------------------------------------------------*/
57
58 #define SET_MASK  DM_AT_ATIME|DM_AT_MTIME|DM_AT_CTIME|DM_AT_DTIME|\
59                   DM_AT_UID|DM_AT_GID|DM_AT_MODE|DM_AT_SIZE 
60
61 #define GET_MASK DM_AT_EMASK|DM_AT_PMANR|DM_AT_PATTR|\
62                   DM_AT_DTIME|DM_AT_CFLAG|DM_AT_STAT
63
64 extern  int     optind;
65 extern  int     opterr;
66 extern  char    *optarg;
67
68 char    *Progname;
69 int     Vflag=0;
70
71
72 int
73 comp_stat ( dm_stat_t expected,
74             dm_stat_t found,
75             int       i)
76 {
77    int good=0;
78    if (found.dt_mode != expected.dt_mode) {
79      fprintf(stderr, 
80              "ERROR: get #%d, expected mode %ld, but found %ld\n",
81              i, (long)expected.dt_mode, (long)found.dt_mode);
82    }
83    else good++;
84    if (found.dt_uid != expected.dt_uid) {
85      fprintf(stderr, 
86              "ERROR: get #%d, expected uid %ld, but found %ld\n",
87              i, (long)expected.dt_uid, (long)found.dt_uid);
88    }
89    else good++;
90    if (found.dt_gid != expected.dt_gid) {
91      fprintf(stderr, 
92              "ERROR: get #%d, expected gid %ld, but found %ld\n",
93              i, (long)expected.dt_gid, (long)found.dt_gid);
94    }
95    else good++;
96    if (found.dt_atime != expected.dt_atime) {
97      fprintf(stderr, 
98              "ERROR: get #%d, expected atime %ld, but found %ld\n",
99              i, expected.dt_atime, found.dt_atime);
100    }
101    else good++;
102    if (found.dt_mtime != expected.dt_mtime) {
103      fprintf(stderr, 
104              "ERROR: get #%d, expected mtime %ld, but found %ld\n",
105              i, expected.dt_mtime, found.dt_mtime);
106    }
107    else good++;
108    if (found.dt_ctime != expected.dt_ctime) {
109      fprintf(stderr, 
110              "ERROR: get #%d, expected ctime %ld, but found %ld\n",
111              i, expected.dt_ctime, found.dt_ctime);
112    }
113    else good++;
114    
115    /* NOTE: dtime gets set to ctime */
116    
117    if (found.dt_dtime != expected.dt_ctime) {
118      fprintf(stderr, 
119              "ERROR: get #%d, expected dtime %ld, but found %ld\n",
120              i, expected.dt_ctime, found.dt_dtime);
121    }
122    else good++;
123    if (found.dt_size != expected.dt_size) {
124      fprintf(stderr, 
125              "ERROR: get #%d, expected size %lld, but found %lld\n",
126              i, expected.dt_size, found.dt_size);
127    }
128    else good++;
129    if (Vflag){
130      if (good==8) {
131        fprintf(stderr, "report: get #%d had no errors.\n",i);
132      } else {
133        fprintf(stderr, "report: %d tests correct for get #%d.\n", 
134                good, i);
135      }
136    }
137    return(good);
138 }
139
140
141 static void
142 usage(void)
143 {
144         fprintf(stderr, 
145                 "Usage: %s [-v] [-s sid] [-n num_files] ls_path pathname\n",
146                 Progname);
147         exit(1);
148 }
149
150
151 int
152 main(
153         int     argc,
154         char    **argv)
155 {
156         dm_sessid_t     sid = DM_NO_SESSION;
157         dm_token_t      test_token = DM_NO_TOKEN;
158         void            *hanp;
159         size_t          hlen;
160         char            *ls_path;
161         char            *pathname;
162         char            test_file[100];
163         char            command[100];
164         int             num_files=50;
165         dm_stat_t       *stat_arr;
166         dm_stat_t       dmstat;
167         dm_fileattr_t   fileattr;
168         char            *name;
169         int             opt;
170         int             oops=1;
171         int             i=0;
172         dm_attrloc_t    loc;
173         size_t          buflen = 16*sizeof(dm_stat_t);
174         size_t          rlen;
175         void            *bufp;
176         dm_stat_t       *statbuf;
177         int             loops=0;
178         void            *fs_hanp;
179         size_t          fs_hlen;
180         void            *targhanp;
181         size_t          targhlen;
182         char            check_name[100];
183         char            *chk_name_p;
184         int             chk_num;
185
186         if (Progname = strrchr(argv[0], '/')) {
187                 Progname++;
188         } else {
189                 Progname = argv[0];
190         }
191
192         opterr = 0;
193         while ((opt = getopt(argc, argv, "vn:s:")) != EOF) {
194                 switch (opt) {
195                 case 'v':
196                          Vflag++;
197                          break;
198                 case 'n':
199                          num_files = atoi(optarg);
200                          break;
201                 case 's': 
202                          sid = atol(optarg);
203                          break;
204                 case '?':
205                          usage();
206                 }
207         }
208         if (optind + 2 != argc) {
209                 usage();
210         }
211         ls_path = argv[optind];
212         pathname = argv[optind+1];
213
214         /* Seed the random number generator */
215         srand((unsigned int)time(NULL)); 
216
217         if (dm_init_service(&name) == -1)  {
218                 fprintf(stderr, "Can't initialize the DMAPI\n");
219                 exit(1);
220         }
221         if (sid == DM_NO_SESSION)
222                 find_test_session(&sid);
223         
224         /* Dynamically allocate stat_arr; */
225         stat_arr = 
226           (dm_stat_t *)malloc(num_files * sizeof(dm_stat_t));
227         
228         printf("Beginning file attribute tests...\n");
229
230         /* Fill in the dm_stat blocks with lots of junk...
231          */
232         for (i=0; i<num_files; i++) {
233           stat_arr[i].dt_atime=(time_t)(rand()+rand()*0x10000);
234           stat_arr[i].dt_mtime=(time_t)(rand()+rand()*0x10000);
235           stat_arr[i].dt_ctime=(time_t)(rand()+rand()*0x10000);
236           stat_arr[i].dt_dtime=(time_t)(rand()+rand()*0x10000);
237           stat_arr[i].dt_uid=(uid_t)(rand()+rand()*0x10000);
238           stat_arr[i].dt_gid=(gid_t)(rand()+rand()*0x10000);
239           stat_arr[i].dt_mode=(mode_t)((rand()%4096)+32768);
240           stat_arr[i].dt_size=((dm_off_t)(rand()+rand()*0x10000)) & 0x3FFFFFFFFFFFF; /* 1 TB max */
241         }       
242
243         /*-----------------------------------------------------*\
244         |* File creation and set_fileattr loop                 *|
245         \*-----------------------------------------------------*/
246         if (Vflag) fprintf(stderr, "\nCreating/setting up test files.\n");
247         for (i=0; i < num_files; i++) {
248           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
249                   pathname, i);
250           sprintf(command, "cp %s %s \n", ls_path, test_file); 
251           system(command);
252
253           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
254             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
255                     test_file, ERR_NAME);
256           }
257           else {
258             fileattr.fa_mode  = stat_arr[i].dt_mode;
259             fileattr.fa_uid   = stat_arr[i].dt_uid;
260             fileattr.fa_gid   = stat_arr[i].dt_gid;
261             fileattr.FA_ATIME = stat_arr[i].dt_atime;
262             fileattr.FA_MTIME = stat_arr[i].dt_mtime;
263             fileattr.FA_CTIME = stat_arr[i].dt_ctime;
264             fileattr.FA_DTIME = stat_arr[i].dt_dtime;
265             fileattr.fa_size  = stat_arr[i].dt_size;
266             if (dm_set_fileattr(sid, hanp, hlen, DM_NO_TOKEN,
267                                 SET_MASK, &fileattr)) {
268               fprintf(stderr, "ERROR: set_fileattr failed on pass #%d; %s.\n",
269                       i, ERR_NAME);
270             }
271             else if (Vflag) {
272               fprintf(stderr, "report: set #%d was successful.\n", i);
273             }
274             if (dm_sync_by_handle(sid, hanp, hlen, DM_NO_TOKEN)) {
275               fprintf(stderr, "dm_sync_by_handle failed on pass #%d; %s.\n",
276                         i, strerror(errno));
277             }
278           }
279         }
280         
281         /*-----------------------------------------------------*\
282         |* Get_fileattr loop                                   *|
283         \*-----------------------------------------------------*/
284         if (Vflag) fprintf(stderr, "\nRunning get_fileattr test\n");
285         for (i=0; i < num_files; i++) {
286           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
287                   pathname, i);
288           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
289             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
290                     test_file, ERR_NAME);
291           }
292           if (dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN,
293                               GET_MASK, &dmstat)) {
294             fprintf(stderr,
295                     "ERROR: dm_get_fileattr failed on pass #%d, %s\n",
296                     i, ERR_NAME);
297           }
298           else {
299             comp_stat(stat_arr[i], dmstat, i); 
300           }
301         }
302           
303         /*-----------------------------------------------------*\
304         |* Get_dirattrs loop                                   *|
305         \*-----------------------------------------------------*/
306         if (Vflag) fprintf(stderr, "\nRunning get_dirattrs test\n");
307         if (dm_path_to_handle(pathname, &hanp, &hlen)) {
308           fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
309                   pathname, ERR_NAME);
310           goto abort_test;
311         }
312         if ((bufp = (void*)malloc(buflen)) == NULL) {
313           fprintf(stderr, "Can't allocate memory for buffer.\n");
314             goto abort_test;
315         }
316         if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
317           fprintf(stderr, 
318                   "ERROR: dm_init_attrloc failed with %s.\n",
319                   ERR_NAME);
320           goto abort_test;
321         }
322         i=0; 
323         loops=0;
324         do {
325           /* printf("About to call get_dirattrs;\tloops=%d\n", loops);
326            * fflush(stdout);
327            * sleep(1);
328            */
329           oops=dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
330                                GET_MASK, &loc, buflen,
331                                bufp, &rlen);
332           if (rlen==0) break;
333           for (statbuf = bufp; statbuf != NULL; 
334                statbuf = DM_STEP_TO_NEXT(statbuf, dm_stat_t *)) {
335             chk_name_p = DM_GET_VALUE(statbuf, dt_compname, void *);
336             if (strncmp(chk_name_p, "DMAPI_fileattr_test.", 20)==0) {
337               sscanf(chk_name_p, "DMAPI_fileattr_test.%d", &chk_num);
338               if (comp_stat(stat_arr[chk_num], *statbuf, chk_num)==8) i++;
339             }
340           }
341           loops++;
342         } while (oops==1);
343         
344         if (oops==-1) {
345           fprintf(stderr, 
346                   "ERROR: dm_get_dirattrs failed with %s.\n",
347                   ERR_NAME);
348         }
349         if (i!=num_files) {
350           fprintf(stderr,
351                   "ERROR: get_dirattrs found %d matching file%s "
352                   "(expected %d).\n", i, (i==1)?"":"s", num_files);
353         }
354         else if (Vflag) {
355           fprintf(stderr, "report: get_dirattrs successfully "
356                   "found %d files in %d loops.\n", i, loops);
357         }
358
359         /*-----------------------------------------------------*\
360         |* Get_bulkattr loop                                   *|
361         \*-----------------------------------------------------*/
362         if (Vflag) fprintf(stderr, "\nRunning get_bulkattr test\n");
363         if (dm_path_to_handle(pathname, &hanp, &hlen)) {
364           fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
365                   pathname, ERR_NAME);
366           goto abort_test;
367         }
368         if (dm_path_to_fshandle(pathname, &fs_hanp, &fs_hlen)) {
369           fprintf(stderr, "ERROR: can't get filesystem handle for %s; %s\n",
370                   pathname, ERR_NAME);
371           goto abort_test;
372         }
373         
374         buflen = 16*sizeof(dm_stat_t); /* 100000000; */  
375         if ((bufp = (void*)malloc(buflen)) == NULL) {
376           fprintf(stderr, "Can't allocate memory for buffer.\n");
377           goto abort_test;
378         }
379         if (dm_init_attrloc(sid, fs_hanp, fs_hlen,
380                             DM_NO_TOKEN, &loc)){
381           fprintf(stderr, 
382                   "ERROR: dm_init_attrloc failed with %s.\n",
383                   ERR_NAME);
384           goto abort_test;
385         }
386         
387         i=0;
388         loops=0;
389         do {
390           oops=dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
391                                GET_MASK, &loc, buflen, bufp, &rlen); 
392           if (rlen==0) break;
393           for( statbuf = bufp; statbuf != NULL;  
394                statbuf = DM_STEP_TO_NEXT(statbuf, dm_stat_t *) ) {
395             targhanp = DM_GET_VALUE(statbuf, dt_handle, void *);
396             targhlen = DM_GET_LEN(statbuf, dt_handle);
397             if (dm_handle_to_path(hanp, hlen, targhanp, targhlen,
398                                   (size_t)100, check_name, &rlen)){
399               fprintf(stderr, 
400                       "Warning: Couldn't get name from handle. (%s)\n",
401                           ERR_NAME);
402             }
403             else {
404               /* Put JUST name (not path) from check_name into chk_name_p */
405               if (chk_name_p = strrchr(check_name, '/')) chk_name_p++;
406               else chk_name_p = check_name;
407               /* Verify that check_name_p holds a testfile name */
408               if (strncmp(chk_name_p, "DMAPI_fileattr_test.",20)==0) {
409                 /* Get the test file's number and compare. */
410                 sscanf(chk_name_p, "DMAPI_fileattr_test.%d", &chk_num);
411                 if (comp_stat(stat_arr[chk_num], *statbuf, chk_num)==8)i++;
412               }
413             }            
414           }
415           loops++;
416         } while (oops==1);
417         
418         if (oops) {
419           fprintf(stderr, 
420                   "ERROR: dm_get_bulkattr failed with %s.\n",
421                   ERR_NAME);
422         }
423         /* printf("All_file_count: %d.  BUFLEN: %d\n",
424          * all_file_count, buflen);
425          */ 
426         if (i!=num_files) {
427           fprintf(stderr,
428                   "ERROR: get_bulkattr found %d matching file%s "
429                   "(expected %d) in %d loops.\n", i, (i==1)?"":"s",
430                   num_files, loops);
431         }
432         else if (Vflag) {
433           fprintf(stderr, "report: get_bulkattr successfully "
434                   "found %d files in %d loops.\n", i, loops);
435         }
436
437           /*------------------------*\
438           |*  ## Errno subtests ##  *|
439           \*------------------------*/
440           printf("\t(errno subtests beginning...)\n");
441           sprintf(test_file, "%s/DMAPI_fileattr_test.ERRNO", 
442                   pathname);
443           sprintf(command, "cp %s %s\n", ls_path, test_file); 
444           system(command);
445
446           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
447             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
448                     test_file, ERR_NAME);
449             goto abort_test;
450           }
451  
452           /*------------------------------------*\
453           |*  ## dm_set_fileattr() subtests ##  *|
454           \*------------------------------------*/
455           /*---------------------------------------------------------*/
456           EXCLTEST("set", hanp, hlen, test_token, 
457                    dm_set_fileattr(sid, hanp, hlen, test_token,
458                                    SET_MASK, &fileattr))
459           /*---------------------------------------------------------*/
460           { void *test_vp;
461           if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
462             fprintf(stderr, 
463                     "Cannot create a test handle (%s); skipping EBADF test\n",
464                     ERR_NAME);
465           }
466           else {
467             ((char *) test_vp)[hlen/2]++;
468             ERRTEST(EBADF,
469                     "set",
470                     dm_set_fileattr(sid, test_vp, hlen, DM_NO_TOKEN,
471                                     SET_MASK, &fileattr))
472               dm_handle_free(test_vp, hlen);
473           }
474           }
475           /*---------------------------------------------------------*/
476           ERRTEST(EFAULT, 
477                   "set",
478                   dm_set_fileattr(sid, NULL, hlen, DM_NO_TOKEN, 
479                                   SET_MASK, &fileattr))
480           /*---------------------------------------------------------*/
481 #if 0
482           PROBLEM: 32 ones as a mask does not produce a "bad mask" 
483           EINVAL.  If it does not, I suspect nothing will.
484
485           ERRTEST(EINVAL, 
486                   "set (bad mask) [BROKEN]",
487                   dm_set_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
488                                   0xFFFFFFFF, &fileattr))
489 #endif
490           /*---------------------------------------------------------*/
491           ERRTEST(EINVAL, 
492                   "set (bad token)",
493                   dm_set_fileattr(sid, hanp, hlen, 0, 
494                                   SET_MASK, &fileattr))
495           /*---------------------------------------------------------*/
496           ERRTEST(EINVAL, 
497                   "set (bad session)",
498                   dm_set_fileattr(-100, hanp, hlen, DM_NO_TOKEN, 
499                                   SET_MASK, &fileattr))
500           /*---------------------------------------------------------*/
501
502
503           /*------------------------------------*\
504           |*  ## dm_get_fileattr() subtests ##  *|
505           \*------------------------------------*/
506           /*---------------------------------------------------------*/
507           SHAREDTEST("get", hanp, hlen, test_token,
508                      dm_get_fileattr(sid, hanp, hlen, test_token,
509                                      GET_MASK, &dmstat))
510           /*---------------------------------------------------------*/
511           { void *test_vp;
512           if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
513             fprintf(stderr, 
514                     "Cannot create a test handle (%s); skipping EBADF test\n",
515                     ERR_NAME);
516           }
517           else {
518             ((char *) test_vp)[hlen/2]++;
519             ERRTEST(EBADF,
520                     "get",
521                     dm_get_fileattr(sid, test_vp, hlen, DM_NO_TOKEN,
522                                     GET_MASK, &dmstat))
523               dm_handle_free(test_vp, hlen);
524           }
525           }
526           /*---------------------------------------------------------*/
527           ERRTEST(EFAULT, 
528                   "get",
529                   dm_get_fileattr(sid, NULL, hlen, DM_NO_TOKEN, 
530                                   GET_MASK, &dmstat))
531           ERRTEST(EFAULT, 
532                   "get",
533                   dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
534                                   GET_MASK, (dm_stat_t *)(-1000)))
535           /*---------------------------------------------------------*/
536 #if 0
537           PROBLEM: 32 ones as a mask does not produce a "bad mask" 
538           EINVAL.  If it does not, I suspect nothing will.
539
540           ERRTEST(EINVAL, 
541                   "get (bad mask) [BROKEN]",
542                   dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
543                                   0xFFFFFFFF, &dmstat))
544 #endif
545           /*---------------------------------------------------------*/
546           ERRTEST(EINVAL, 
547                   "get (bad token)",
548                   dm_get_fileattr(sid, hanp, hlen, 0, 
549                                   GET_MASK, &dmstat))
550           /*---------------------------------------------------------*/
551           ERRTEST(EINVAL, 
552                   "get (bad session)",
553                   dm_get_fileattr(-100, hanp, hlen, DM_NO_TOKEN, 
554                                   GET_MASK, &dmstat))
555           /*---------------------------------------------------------*/
556             
557
558           dm_handle_free(hanp, hlen);
559
560           /*------------------------------------*\
561           |*  ## dm_get_dirattrs() subtests ##  *|
562           \*------------------------------------*/
563           if (dm_path_to_handle(pathname, &hanp, &hlen)) {
564             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
565                     pathname, ERR_NAME);
566           }
567           else if ((bufp = (void*)malloc(buflen)) == NULL) {
568             fprintf(stderr, "Can't allocate memory for buffer.\n");
569           }
570           else {
571             /*---------------------------------------------------------*/
572             if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
573               fprintf(stderr, 
574                       "ERROR: dm_init_attrloc failed with %s.\n",
575                       ERR_NAME);
576             } else {
577               SHAREDTEST("get_dir", hanp, hlen, test_token, 
578                          dm_get_dirattrs(sid, hanp, hlen, test_token,
579                                          GET_MASK, &loc, buflen, bufp, &rlen))
580             }
581             /*---------------------------------------------------------*/
582             { void* test_vp;
583               if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
584                 fprintf(stderr,  "ERROR: dm_init_attrloc failed with %s.\n",
585                         ERR_NAME);
586               } 
587               else if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
588                 fprintf(stderr, "Cannot create a test handle (%s); "
589                         "skipping EBADF test\n", ERR_NAME);
590               }
591               else {
592                 ((char *) test_vp)[hlen/2]++;
593                 ERRTEST(EBADF,
594                         "get",
595                         dm_get_dirattrs(sid, test_vp, hlen, DM_NO_TOKEN,
596                                         GET_MASK, &loc, buflen, bufp, &rlen))
597                 dm_handle_free(test_vp, hlen);
598               }
599             }
600             /*---------------------------------------------------------*/
601             { 
602               if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
603                 fprintf(stderr, 
604                         "ERROR: dm_init_attrloc failed with %s.\n",
605                         ERR_NAME);
606               } 
607               else {
608                 /* PROBLEM:
609                    This would test alignment.  Right now, no error occurs
610                    when the buffer is "out of sync" with struct size.
611                    It makes it tough to read from the buffer, tho!
612                   ERRTEST(EFAULT,
613                         "get_dir (bad bufp)",
614                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
615                                         GET_MASK, &loc, buflen, p, &rlen))
616                 */
617                 ERRTEST(EFAULT,
618                         "get_dir (bad locp)",
619                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
620                                         GET_MASK, (dm_attrloc_t*)(-1000),
621                                         buflen, bufp, &rlen))
622                 ERRTEST(EFAULT,
623                         "get_dir (bad bufp)",
624                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
625                                         GET_MASK, &loc, buflen, 
626                                         (void*)(-1000), &rlen))
627                 ERRTEST(EFAULT,
628                         "get_dir (bad rlenp)",
629                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
630                                         GET_MASK, &loc, buflen, bufp,
631                                         (size_t*)(-1000)))
632               }
633             }
634             /*---------------------------------------------------------*/
635             /*---------------------------------------------------------*/
636           }
637             
638          /*------------------------------------*\
639          |*  ## dm_get_bulkattr() subtests ##  *|
640          \*------------------------------------*/
641          if (dm_path_to_fshandle(pathname, &fs_hanp, &fs_hlen)) {
642            fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
643                    pathname, ERR_NAME);
644          }
645          else if ((bufp = (void*)malloc(buflen)) == NULL) {
646            fprintf(stderr, "Can't allocate memory for buffer.\n");
647          }
648          else {
649            /*---------------------------------------------------------*/
650            if (dm_init_attrloc(sid, fs_hanp, fs_hlen, DM_NO_TOKEN, &loc)){
651              fprintf(stderr, 
652                      "ERROR: dm_init_attrloc failed with %s.\n",
653                      ERR_NAME);
654            } 
655            else {
656              SHAREDTEST("get_bulk", fs_hanp, fs_hlen, test_token, 
657                         dm_get_bulkattr(sid, fs_hanp, fs_hlen, test_token,
658                                         GET_MASK, &loc, buflen, bufp, &rlen))
659            }
660            /*---------------------------------------------------------*/
661            if (dm_init_attrloc(sid, fs_hanp, fs_hlen, DM_NO_TOKEN, &loc)){
662              fprintf(stderr, 
663                      "ERROR: dm_init_attrloc failed with %s.\n",
664                      ERR_NAME);
665            }
666            else {
667              void *p = (void *)(((char *)bufp)+1);
668              ERRTEST(EFAULT, "get_bulk (bad bufp)",
669                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
670                                      GET_MASK, &loc, buflen, 
671                                      (void *)(-1000), &rlen))
672              ERRTEST(EFAULT, "get_bulk (bad locp)",
673                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
674                                      GET_MASK, (dm_attrloc_t *)(-1000),
675                                      buflen, bufp, &rlen))
676              ERRTEST(EFAULT, "get_bulk (bad rlenp)", 
677                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
678                                      GET_MASK, &loc, buflen, bufp,
679                                      (u_int*)(-1000)))
680              ERRTEST(EFAULT, "get_bulk (bad bufp)",
681                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
682                                      GET_MASK, &loc, buflen, p, &rlen))
683            }
684            /*---------------------------------------------------------*/
685          }
686          
687           sprintf(command, "rm %s/DMAPI_fileattr_test.ERRNO\n", pathname); 
688           system(command);
689           printf("\t(errno subtests complete)\n");
690           /*---------------------*\
691           |* End of errno tests  *|
692           \*---------------------*/
693
694 abort_test:
695         /* File deletion loop */
696         if (Vflag) printf("(Deleting test files...)\n"); 
697         for (i=0; i < num_files; i++) {
698           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
699                   pathname, i);
700           sprintf(command, "rm %s\n", test_file); 
701           system(command);
702         }
703         printf("File attribute tests complete.\n");
704         exit(0);
705 }