Fix unexpected 32 bit sign extension for linux time. It was fine for Irix.
[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           /*
234            * XFS inode timestamp t_sec is a 32 bit signed value. rand() only
235            * returns 15 bits of random number, and so the rand()*0x10000 is
236            * really a rand() << 16 to populate the upper 16 bits of
237            * the timestamp.IOWs, linux does not need this but irix does.
238            */
239           stat_arr[i].dt_atime=((time_t)(rand()+rand()*0x10000) & 0x7FFFFFFF);
240           stat_arr[i].dt_mtime=((time_t)(rand()+rand()*0x10000) & 0x7FFFFFFF);
241           stat_arr[i].dt_ctime=((time_t)(rand()+rand()*0x10000) & 0x7FFFFFFF);
242           stat_arr[i].dt_dtime=((time_t)(rand()+rand()*0x10000) & 0x7FFFFFFF);
243
244           stat_arr[i].dt_uid=(uid_t)(rand()+rand()*0x10000);
245           stat_arr[i].dt_gid=(gid_t)(rand()+rand()*0x10000);
246           stat_arr[i].dt_mode=(mode_t)((rand()%4096)+32768);
247           stat_arr[i].dt_size=((dm_off_t)(rand()+rand()*0x10000)) & 0x3FFFFFFFFFFFF; /* 1 TB max */
248         }       
249
250         /*-----------------------------------------------------*\
251         |* File creation and set_fileattr loop                 *|
252         \*-----------------------------------------------------*/
253         if (Vflag) fprintf(stderr, "\nCreating/setting up test files.\n");
254         for (i=0; i < num_files; i++) {
255           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
256                   pathname, i);
257           sprintf(command, "cp %s %s \n", ls_path, test_file); 
258           system(command);
259
260           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
261             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
262                     test_file, ERR_NAME);
263           }
264           else {
265             fileattr.fa_mode  = stat_arr[i].dt_mode;
266             fileattr.fa_uid   = stat_arr[i].dt_uid;
267             fileattr.fa_gid   = stat_arr[i].dt_gid;
268             fileattr.FA_ATIME = stat_arr[i].dt_atime;
269             fileattr.FA_MTIME = stat_arr[i].dt_mtime;
270             fileattr.FA_CTIME = stat_arr[i].dt_ctime;
271             fileattr.FA_DTIME = stat_arr[i].dt_dtime;
272             fileattr.fa_size  = stat_arr[i].dt_size;
273             if (dm_set_fileattr(sid, hanp, hlen, DM_NO_TOKEN,
274                                 SET_MASK, &fileattr)) {
275               fprintf(stderr, "ERROR: set_fileattr failed on pass #%d; %s.\n",
276                       i, ERR_NAME);
277             }
278             else if (Vflag) {
279               fprintf(stderr, "report: set #%d was successful.\n", i);
280             }
281           }
282         }
283         sync();
284         /*-----------------------------------------------------*\
285         |* Get_fileattr loop                                   *|
286         \*-----------------------------------------------------*/
287         if (Vflag) fprintf(stderr, "\nRunning get_fileattr test\n");
288         for (i=0; i < num_files; i++) {
289           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
290                   pathname, i);
291           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
292             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
293                     test_file, ERR_NAME);
294           }
295           if (dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN,
296                               GET_MASK, &dmstat)) {
297             fprintf(stderr,
298                     "ERROR: dm_get_fileattr failed on pass #%d, %s\n",
299                     i, ERR_NAME);
300           }
301           else {
302             comp_stat(stat_arr[i], dmstat, i); 
303           }
304         }
305           
306         /*-----------------------------------------------------*\
307         |* Get_dirattrs loop                                   *|
308         \*-----------------------------------------------------*/
309         if (Vflag) fprintf(stderr, "\nRunning get_dirattrs test\n");
310         if (dm_path_to_handle(pathname, &hanp, &hlen)) {
311           fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
312                   pathname, ERR_NAME);
313           goto abort_test;
314         }
315         if ((bufp = (void*)malloc(buflen)) == NULL) {
316           fprintf(stderr, "Can't allocate memory for buffer.\n");
317             goto abort_test;
318         }
319         if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
320           fprintf(stderr, 
321                   "ERROR: dm_init_attrloc failed with %s.\n",
322                   ERR_NAME);
323           goto abort_test;
324         }
325         i=0; 
326         loops=0;
327         do {
328           /* printf("About to call get_dirattrs;\tloops=%d\n", loops);
329            * fflush(stdout);
330            * sleep(1);
331            */
332           oops=dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
333                                GET_MASK, &loc, buflen,
334                                bufp, &rlen);
335           if (rlen==0) break;
336           for (statbuf = bufp; statbuf != NULL; 
337                statbuf = DM_STEP_TO_NEXT(statbuf, dm_stat_t *)) {
338             chk_name_p = DM_GET_VALUE(statbuf, dt_compname, void *);
339             if (strncmp(chk_name_p, "DMAPI_fileattr_test.", 20)==0) {
340               sscanf(chk_name_p, "DMAPI_fileattr_test.%d", &chk_num);
341               if (comp_stat(stat_arr[chk_num], *statbuf, chk_num)==8) i++;
342             }
343           }
344           loops++;
345         } while (oops==1);
346         
347         if (oops==-1) {
348           fprintf(stderr, 
349                   "ERROR: dm_get_dirattrs failed with %s.\n",
350                   ERR_NAME);
351         }
352         if (i!=num_files) {
353           fprintf(stderr,
354                   "ERROR: get_dirattrs found %d matching file%s "
355                   "(expected %d).\n", i, (i==1)?"":"s", num_files);
356         }
357         else if (Vflag) {
358           fprintf(stderr, "report: get_dirattrs successfully "
359                   "found %d files in %d loops.\n", i, loops);
360         }
361
362         /*-----------------------------------------------------*\
363         |* Get_bulkattr loop                                   *|
364         \*-----------------------------------------------------*/
365         if (Vflag) fprintf(stderr, "\nRunning get_bulkattr test\n");
366         if (dm_path_to_handle(pathname, &hanp, &hlen)) {
367           fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
368                   pathname, ERR_NAME);
369           goto abort_test;
370         }
371         if (dm_path_to_fshandle(pathname, &fs_hanp, &fs_hlen)) {
372           fprintf(stderr, "ERROR: can't get filesystem handle for %s; %s\n",
373                   pathname, ERR_NAME);
374           goto abort_test;
375         }
376         
377         buflen = 16*sizeof(dm_stat_t); /* 100000000; */  
378         if ((bufp = (void*)malloc(buflen)) == NULL) {
379           fprintf(stderr, "Can't allocate memory for buffer.\n");
380           goto abort_test;
381         }
382         if (dm_init_attrloc(sid, fs_hanp, fs_hlen,
383                             DM_NO_TOKEN, &loc)){
384           fprintf(stderr, 
385                   "ERROR: dm_init_attrloc failed with %s.\n",
386                   ERR_NAME);
387           goto abort_test;
388         }
389         
390         i=0;
391         loops=0;
392         do {
393           oops=dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
394                                GET_MASK, &loc, buflen, bufp, &rlen); 
395           if (rlen==0) break;
396           for( statbuf = bufp; statbuf != NULL;  
397                statbuf = DM_STEP_TO_NEXT(statbuf, dm_stat_t *) ) {
398             targhanp = DM_GET_VALUE(statbuf, dt_handle, void *);
399             targhlen = DM_GET_LEN(statbuf, dt_handle);
400             if (dm_handle_to_path(hanp, hlen, targhanp, targhlen,
401                                   (size_t)100, check_name, &rlen)){
402               fprintf(stderr, 
403                       "Warning: Couldn't get name from handle. (%s)\n",
404                           ERR_NAME);
405             }
406             else {
407               /* Put JUST name (not path) from check_name into chk_name_p */
408               if (chk_name_p = strrchr(check_name, '/')) chk_name_p++;
409               else chk_name_p = check_name;
410               /* Verify that check_name_p holds a testfile name */
411               if (strncmp(chk_name_p, "DMAPI_fileattr_test.",20)==0) {
412                 /* Get the test file's number and compare. */
413                 sscanf(chk_name_p, "DMAPI_fileattr_test.%d", &chk_num);
414                 if (comp_stat(stat_arr[chk_num], *statbuf, chk_num)==8)i++;
415               }
416             }            
417           }
418           loops++;
419         } while (oops==1);
420         
421         if (oops) {
422           fprintf(stderr, 
423                   "ERROR: dm_get_bulkattr failed with %s.\n",
424                   ERR_NAME);
425         }
426         /* printf("All_file_count: %d.  BUFLEN: %d\n",
427          * all_file_count, buflen);
428          */ 
429         if (i!=num_files) {
430           fprintf(stderr,
431                   "ERROR: get_bulkattr found %d matching file%s "
432                   "(expected %d) in %d loops.\n", i, (i==1)?"":"s",
433                   num_files, loops);
434         }
435         else if (Vflag) {
436           fprintf(stderr, "report: get_bulkattr successfully "
437                   "found %d files in %d loops.\n", i, loops);
438         }
439
440           /*------------------------*\
441           |*  ## Errno subtests ##  *|
442           \*------------------------*/
443           printf("\t(errno subtests beginning...)\n");
444           sprintf(test_file, "%s/DMAPI_fileattr_test.ERRNO", 
445                   pathname);
446           sprintf(command, "cp %s %s\n", ls_path, test_file); 
447           system(command);
448
449           if (dm_path_to_handle(test_file, &hanp, &hlen)) {
450             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
451                     test_file, ERR_NAME);
452             goto abort_test;
453           }
454  
455           /*------------------------------------*\
456           |*  ## dm_set_fileattr() subtests ##  *|
457           \*------------------------------------*/
458           /*---------------------------------------------------------*/
459           EXCLTEST("set", hanp, hlen, test_token, 
460                    dm_set_fileattr(sid, hanp, hlen, test_token,
461                                    SET_MASK, &fileattr))
462           /*---------------------------------------------------------*/
463           { void *test_vp;
464           if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
465             fprintf(stderr, 
466                     "Cannot create a test handle (%s); skipping EBADF test\n",
467                     ERR_NAME);
468           }
469           else {
470             ((char *) test_vp)[hlen/2]++;
471             ERRTEST(EBADF,
472                     "set",
473                     dm_set_fileattr(sid, test_vp, hlen, DM_NO_TOKEN,
474                                     SET_MASK, &fileattr))
475               dm_handle_free(test_vp, hlen);
476           }
477           }
478           /*---------------------------------------------------------*/
479           ERRTEST(EFAULT, 
480                   "set",
481                   dm_set_fileattr(sid, NULL, hlen, DM_NO_TOKEN, 
482                                   SET_MASK, &fileattr))
483           /*---------------------------------------------------------*/
484 #if 0
485           PROBLEM: 32 ones as a mask does not produce a "bad mask" 
486           EINVAL.  If it does not, I suspect nothing will.
487
488           ERRTEST(EINVAL, 
489                   "set (bad mask) [BROKEN]",
490                   dm_set_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
491                                   0xFFFFFFFF, &fileattr))
492 #endif
493           /*---------------------------------------------------------*/
494           ERRTEST(EINVAL, 
495                   "set (bad token)",
496                   dm_set_fileattr(sid, hanp, hlen, 0, 
497                                   SET_MASK, &fileattr))
498           /*---------------------------------------------------------*/
499           ERRTEST(EINVAL, 
500                   "set (bad session)",
501                   dm_set_fileattr(-100, hanp, hlen, DM_NO_TOKEN, 
502                                   SET_MASK, &fileattr))
503           /*---------------------------------------------------------*/
504
505
506           /*------------------------------------*\
507           |*  ## dm_get_fileattr() subtests ##  *|
508           \*------------------------------------*/
509           /*---------------------------------------------------------*/
510           SHAREDTEST("get", hanp, hlen, test_token,
511                      dm_get_fileattr(sid, hanp, hlen, test_token,
512                                      GET_MASK, &dmstat))
513           /*---------------------------------------------------------*/
514           { void *test_vp;
515           if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
516             fprintf(stderr, 
517                     "Cannot create a test handle (%s); skipping EBADF test\n",
518                     ERR_NAME);
519           }
520           else {
521             ((char *) test_vp)[hlen/2]++;
522             ERRTEST(EBADF,
523                     "get",
524                     dm_get_fileattr(sid, test_vp, hlen, DM_NO_TOKEN,
525                                     GET_MASK, &dmstat))
526               dm_handle_free(test_vp, hlen);
527           }
528           }
529           /*---------------------------------------------------------*/
530           ERRTEST(EFAULT, 
531                   "get",
532                   dm_get_fileattr(sid, NULL, hlen, DM_NO_TOKEN, 
533                                   GET_MASK, &dmstat))
534           ERRTEST(EFAULT, 
535                   "get",
536                   dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
537                                   GET_MASK, (dm_stat_t *)(-1000)))
538           /*---------------------------------------------------------*/
539 #if 0
540           PROBLEM: 32 ones as a mask does not produce a "bad mask" 
541           EINVAL.  If it does not, I suspect nothing will.
542
543           ERRTEST(EINVAL, 
544                   "get (bad mask) [BROKEN]",
545                   dm_get_fileattr(sid, hanp, hlen, DM_NO_TOKEN, 
546                                   0xFFFFFFFF, &dmstat))
547 #endif
548           /*---------------------------------------------------------*/
549           ERRTEST(EINVAL, 
550                   "get (bad token)",
551                   dm_get_fileattr(sid, hanp, hlen, 0, 
552                                   GET_MASK, &dmstat))
553           /*---------------------------------------------------------*/
554           ERRTEST(EINVAL, 
555                   "get (bad session)",
556                   dm_get_fileattr(-100, hanp, hlen, DM_NO_TOKEN, 
557                                   GET_MASK, &dmstat))
558           /*---------------------------------------------------------*/
559             
560
561           dm_handle_free(hanp, hlen);
562
563           /*------------------------------------*\
564           |*  ## dm_get_dirattrs() subtests ##  *|
565           \*------------------------------------*/
566           if (dm_path_to_handle(pathname, &hanp, &hlen)) {
567             fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
568                     pathname, ERR_NAME);
569           }
570           else if ((bufp = (void*)malloc(buflen)) == NULL) {
571             fprintf(stderr, "Can't allocate memory for buffer.\n");
572           }
573           else {
574             /*---------------------------------------------------------*/
575             if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
576               fprintf(stderr, 
577                       "ERROR: dm_init_attrloc failed with %s.\n",
578                       ERR_NAME);
579             } else {
580               SHAREDTEST("get_dir", hanp, hlen, test_token, 
581                          dm_get_dirattrs(sid, hanp, hlen, test_token,
582                                          GET_MASK, &loc, buflen, bufp, &rlen))
583             }
584             /*---------------------------------------------------------*/
585             { void* test_vp;
586               if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
587                 fprintf(stderr,  "ERROR: dm_init_attrloc failed with %s.\n",
588                         ERR_NAME);
589               } 
590               else if ((test_vp = handle_clone(hanp, hlen)) == NULL) {
591                 fprintf(stderr, "Cannot create a test handle (%s); "
592                         "skipping EBADF test\n", ERR_NAME);
593               }
594               else {
595                 ((char *) test_vp)[hlen/2]++;
596                 ERRTEST(EBADF,
597                         "get",
598                         dm_get_dirattrs(sid, test_vp, hlen, DM_NO_TOKEN,
599                                         GET_MASK, &loc, buflen, bufp, &rlen))
600                 dm_handle_free(test_vp, hlen);
601               }
602             }
603             /*---------------------------------------------------------*/
604             { 
605               if (dm_init_attrloc(sid, hanp, hlen, DM_NO_TOKEN, &loc)){
606                 fprintf(stderr, 
607                         "ERROR: dm_init_attrloc failed with %s.\n",
608                         ERR_NAME);
609               } 
610               else {
611                 /* PROBLEM:
612                    This would test alignment.  Right now, no error occurs
613                    when the buffer is "out of sync" with struct size.
614                    It makes it tough to read from the buffer, tho!
615                   ERRTEST(EFAULT,
616                         "get_dir (bad bufp)",
617                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
618                                         GET_MASK, &loc, buflen, p, &rlen))
619                 */
620                 ERRTEST(EFAULT,
621                         "get_dir (bad locp)",
622                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
623                                         GET_MASK, (dm_attrloc_t*)(-1000),
624                                         buflen, bufp, &rlen))
625                 ERRTEST(EFAULT,
626                         "get_dir (bad bufp)",
627                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
628                                         GET_MASK, &loc, buflen, 
629                                         (void*)(-1000), &rlen))
630                 ERRTEST(EFAULT,
631                         "get_dir (bad rlenp)",
632                         dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN,
633                                         GET_MASK, &loc, buflen, bufp,
634                                         (size_t*)(-1000)))
635               }
636             }
637             /*---------------------------------------------------------*/
638             /*---------------------------------------------------------*/
639           }
640             
641          /*------------------------------------*\
642          |*  ## dm_get_bulkattr() subtests ##  *|
643          \*------------------------------------*/
644          if (dm_path_to_fshandle(pathname, &fs_hanp, &fs_hlen)) {
645            fprintf(stderr, "ERROR: can't get handle for %s; %s\n",
646                    pathname, ERR_NAME);
647          }
648          else if ((bufp = (void*)malloc(buflen)) == NULL) {
649            fprintf(stderr, "Can't allocate memory for buffer.\n");
650          }
651          else {
652            /*---------------------------------------------------------*/
653            if (dm_init_attrloc(sid, fs_hanp, fs_hlen, DM_NO_TOKEN, &loc)){
654              fprintf(stderr, 
655                      "ERROR: dm_init_attrloc failed with %s.\n",
656                      ERR_NAME);
657            } 
658            else {
659              SHAREDTEST("get_bulk", fs_hanp, fs_hlen, test_token, 
660                         dm_get_bulkattr(sid, fs_hanp, fs_hlen, test_token,
661                                         GET_MASK, &loc, buflen, bufp, &rlen))
662            }
663            /*---------------------------------------------------------*/
664            if (dm_init_attrloc(sid, fs_hanp, fs_hlen, DM_NO_TOKEN, &loc)){
665              fprintf(stderr, 
666                      "ERROR: dm_init_attrloc failed with %s.\n",
667                      ERR_NAME);
668            }
669            else {
670              void *p = (void *)(((char *)bufp)+1);
671              ERRTEST(EFAULT, "get_bulk (bad bufp)",
672                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
673                                      GET_MASK, &loc, buflen, 
674                                      (void *)(-1000), &rlen))
675              ERRTEST(EFAULT, "get_bulk (bad locp)",
676                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
677                                      GET_MASK, (dm_attrloc_t *)(-1000),
678                                      buflen, bufp, &rlen))
679              ERRTEST(EFAULT, "get_bulk (bad rlenp)", 
680                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
681                                      GET_MASK, &loc, buflen, bufp,
682                                      (u_int*)(-1000)))
683              ERRTEST(EFAULT, "get_bulk (bad bufp)",
684                      dm_get_bulkattr(sid, fs_hanp, fs_hlen, DM_NO_TOKEN,
685                                      GET_MASK, &loc, buflen, p, &rlen))
686            }
687            /*---------------------------------------------------------*/
688          }
689          
690           sprintf(command, "rm %s/DMAPI_fileattr_test.ERRNO\n", pathname); 
691           system(command);
692           printf("\t(errno subtests complete)\n");
693           /*---------------------*\
694           |* End of errno tests  *|
695           \*---------------------*/
696
697 abort_test:
698         /* File deletion loop */
699         if (Vflag) printf("(Deleting test files...)\n"); 
700         for (i=0; i < num_files; i++) {
701           sprintf(test_file, "%s/DMAPI_fileattr_test.%d", 
702                   pathname, i);
703           sprintf(command, "rm %s\n", test_file); 
704           system(command);
705         }
706         printf("File attribute tests complete.\n");
707         exit(0);
708 }