dmapi/src/suite1/cmd/dm_handle.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 <fcntl.h>
  23 #include <unistd.h>
  24
  25 #include <lib/hsm.h>
  26
  27 #include <string.h>
  28
  29 /*---------------------------------------------------------------------------
  30
  31 Test program used to test all the DMAPI functions in dm_handle.c.  The
  32 command line is:
  33
  34         dm_handle pathname
  35
  36 where pathname is the name of a file.  If any function fails, an error message
  37 containing the work ERROR will be written to stderr.
  38
  39 Tested DMAPI functions are:
  40         dm_fd_to_handle
  41         dm_handle_cmp
  42         dm_handle_free
  43         dm_handle_hash
  44         dm_handle_is_valid
  45         dm_handle_to_fshandle
  46         dm_handle_to_fsid
  47         dm_handle_to_ino
  48         dm_handle_to_igen
  49         dm_make_handle
  50         dm_make_fshandle
  51         dm_path_to_handle
  52         dm_path_to_fshandle
  53
  54 ----------------------------------------------------------------------------*/
  55
  56
  57 char    *Progname;
  58
  59
  60
  61 int
  62 main(
  63         int             argc,
  64         char            **argv)
  65 {
  66         char            *pathname;
  67         char            *name;
  68         void            *hanp1, *hanp2, *hanp3, *fshanp1, *fshanp2, *fshanp3;
  69         size_t          hlen1, hlen2, hlen3, fshlen1, fshlen2, fshlen3;
  70         u_int           hash1, hash2, hash3, fshash1, fshash2, fshash3;
  71         dm_fsid_t       fsid;
  72         dm_ino_t        ino;
  73         dm_igen_t       igen;
  74         char            buffer[100];
  75         char            buffer1[100];
  76         char            fsbuffer1[100];
  77         char            buffer2[100];
  78         char            fsbuffer2[100];
  79         char            buffer3[100];
  80         char            fsbuffer3[100];
  81         int             fd;
  82
  83         if (Progname = strrchr(argv[0], '/')) {
  84                 Progname++;
  85         } else {
  86                 Progname = argv[0];
  87         }
  88
  89         if (argc != 2) {
  90                 fprintf(stderr, "usage: %s path\n", argv[0]);
  91                 exit(1);
  92         }
  93         pathname = argv[1];
  94
  95         (void)dm_init_service(&name);
  96
  97         if (dm_path_to_handle(pathname, &hanp1, &hlen1) != 0) {
  98                 fprintf(stderr, "dm_path_to_handle failed, %s\n",
  99                         strerror(errno));
 100                 exit(1);
 101         }
 102         hash1 = dm_handle_hash(hanp1, hlen1);
 103         hantoa(hanp1, hlen1, buffer1);
 104         fprintf(stdout, "  han1:  hash %u  value %s  (dm_path_to_handle)\n",
 105                 hash1, buffer1);
 106         if (dm_handle_is_valid(hanp1, hlen1) == DM_FALSE) {
 107                 fprintf(stderr, "ERROR: han1 is not valid\n");
 108         }
 109
 110         if (dm_path_to_fshandle(pathname, &fshanp1, &fshlen1) != 0) {
 111                 fprintf(stderr, "dm_path_to_fshandle failed, %s\n",
 112                         strerror(errno));
 113                 exit(1);
 114         }
 115         fshash1 = dm_handle_hash(fshanp1, fshlen1);
 116         hantoa(fshanp1, fshlen1, fsbuffer1);
 117         fprintf(stdout, "fshan1:  hash %u  value %s  (dm_path_to_fshandle\n",
 118                 fshash1, fsbuffer1);
 119         if (dm_handle_is_valid(fshanp1, fshlen1) == DM_FALSE) {
 120                 fprintf(stderr, "ERROR: fshan1 is not valid\n");
 121         }
 122
 123         if ((fd = open(pathname, O_RDONLY)) < 0) {
 124                 fprintf(stderr, "open of %s failed, %s\n", pathname,
 125                         strerror(errno));
 126                 exit(1);
 127         }
 128         if (dm_fd_to_handle(fd, &hanp2, &hlen2) != 0) {
 129                 fprintf(stderr, "dm_fd_to_handle failed, %s\n",
 130                         strerror(errno));
 131                 exit(1);
 132         }
 133         (void)close(fd);
 134         hash2 = dm_handle_hash(hanp2, hlen2);
 135         hantoa(hanp2, hlen2, buffer2);
 136         fprintf(stdout, "  han2:  hash %u  value %s  (dm_fd_to_handle)\n",
 137                 hash2, buffer2);
 138         if (dm_handle_is_valid(hanp2, hlen2) == DM_FALSE) {
 139                 fprintf(stderr, "ERROR: han2 is not valid\n");
 140         }
 141
 142         if (dm_handle_to_fshandle(hanp2, hlen2, &fshanp2, &fshlen2) != 0) {
 143                 fprintf(stderr, "dm_handle_to_fshandle failed, %s\n",
 144                         strerror(errno));
 145                 exit(1);
 146         }
 147         fshash2 = dm_handle_hash(fshanp2, fshlen2);
 148         hantoa(fshanp2, fshlen2, fsbuffer2);
 149         fprintf(stdout, "fshan2:  hash %u  value %s  (dm_handle_to_fshandle)\n",
 150                 fshash2, fsbuffer2);
 151         if (dm_handle_is_valid(fshanp2, fshlen2) == DM_FALSE) {
 152                 fprintf(stderr, "ERROR: fshan2 is not valid\n");
 153         }
 154
 155         if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2)) {
 156                 fprintf(stderr, "ERROR: han1 and han2 differ in dm_handle_cmp\n");
 157         }
 158         if (strcmp(buffer1, buffer2)) {
 159                 fprintf(stderr, "ERROR: han1 and han2 differ in strcmp\n");
 160         }
 161         if (hash1 != hash2) {
 162                 fprintf(stderr, "ERROR: hash1 and hash2 differ\n");
 163         }
 164
 165         if (dm_handle_cmp(fshanp1, fshlen1, fshanp2, fshlen2)) {
 166                 fprintf(stderr, "ERROR: fshan1 and fshan2 differ in dm_handle_cmp\n");
 167         }
 168         if (strcmp(fsbuffer1, fsbuffer2)) {
 169                 fprintf(stderr, "ERROR: fshan1 and fshan2 differ in strcmp\n");
 170         }
 171         if (fshash1 != fshash2) {
 172                 fprintf(stderr, "ERROR: fshash1 and fshash2 differ\n");
 173         }
 174
 175         /* Break the handle into its component parts and display them.  Use
 176            hantoa() instead of printing the parts directly because some are
 177            32 bits on Veritas and 64 bits on SGI.
 178         */
 179
 180         if (dm_handle_to_fsid(hanp1, hlen1, &fsid) != 0) {
 181                 fprintf(stderr, "dm_handle_to_fsid failed, %s\n",
 182                         strerror(errno));
 183                 exit(1);
 184         }
 185         hantoa(&fsid, sizeof(fsid), buffer);
 186         fprintf(stdout, "fsid  %s       (dm_handle_to_fsid)\n", buffer);
 187
 188         if (dm_handle_to_ino(hanp1, hlen1, &ino) != 0) {
 189                 fprintf(stderr, "dm_handle_to_ino failed, %s\n",
 190                         strerror(errno));
 191                 exit(1);
 192         }
 193         hantoa(&ino, sizeof(ino), buffer);
 194         fprintf(stdout, "ino   %s       (dm_handle_to_ino)\n", buffer);
 195
 196         if (dm_handle_to_igen(hanp1, hlen1, &igen) != 0) {
 197                 fprintf(stderr, "dm_handle_to_igen failed, %s\n",
 198                         strerror(errno));
 199                 exit(1);
 200         }
 201         hantoa(&igen, sizeof(igen), buffer);
 202         fprintf(stdout, "igen  %s       (dm_handle_to_igen)\n", buffer);
 203
 204         /* Now use the parts to remake the handle and verify we get the same
 205            answer.
 206         */
 207
 208         if (dm_make_handle(&fsid, &ino, &igen, &hanp3, &hlen3) != 0) {
 209                 fprintf(stderr, "dm_make_handle failed, %s\n",
 210                         strerror(errno));
 211                 exit(1);
 212         }
 213         hash3 = dm_handle_hash(hanp3, hlen3);
 214         hantoa(hanp3, hlen3, buffer3);
 215         fprintf(stdout, "  han3:  hash %u  value %s  (dm_make_handle)\n",
 216                 hash3, buffer3);
 217         if (dm_handle_is_valid(hanp3, hlen3) == DM_FALSE) {
 218                 fprintf(stderr, "ERROR: han3 is not valid\n");
 219         }
 220
 221         if (dm_handle_cmp(hanp1, hlen1, hanp3, hlen3)) {
 222                 fprintf(stderr, "ERROR: hanp1 and hanp3 differ in dm_handle_cmp\n");
 223         }
 224         if (strcmp(buffer1, buffer3)) {
 225                 fprintf(stderr, "ERROR: hanp1 and hanp3 differ in strcmp\n");
 226         }
 227         if (hash1 != hash3) {
 228                 fprintf(stderr, "ERROR: hash1 and hash3 differ\n");
 229         }
 230
 231         if (dm_make_fshandle(&fsid, &fshanp3, &fshlen3) != 0) {
 232                 fprintf(stderr, "dm_make_fshandle failed, %s\n",
 233                         strerror(errno));
 234                 exit(1);
 235         }
 236         fshash3 = dm_handle_hash(fshanp3, fshlen3);
 237         hantoa(fshanp3, fshlen3, fsbuffer3);
 238         fprintf(stdout, "fshan3:  hash %u  value %s  (dm_make_fshandle)\n",
 239                 fshash3, fsbuffer3);
 240         if (dm_handle_is_valid(fshanp3, fshlen3) == DM_FALSE) {
 241                 fprintf(stderr, "ERROR: fshan3 is not valid\n");
 242         }
 243
 244         if (dm_handle_cmp(fshanp1, fshlen1, fshanp3, fshlen3)) {
 245                 fprintf(stderr, "ERROR: fshan1 and fshan3 differ in dm_handle_cmp\n");
 246         }
 247         if (strcmp(fsbuffer1, fsbuffer3)) {
 248                 fprintf(stderr, "ERROR: fshan1 and fshan3 differ in strcmp\n");
 249         }
 250         if (fshash1 != fshash3) {
 251                 fprintf(stderr, "ERROR: fshash1 and fshash3 differ\n");
 252         }
 253
 254         dm_handle_free(hanp1, hlen1);
 255         dm_handle_free(hanp2, hlen2);
 256         dm_handle_free(hanp3, hlen3);
 257         dm_handle_free(fshanp1, fshlen1);
 258         dm_handle_free(fshanp2, fshlen2);
 259         dm_handle_free(fshanp3, fshlen3);
 260         exit(0);
 261 }