int
main(
int argc,
char **argv)
{
char *name;
int fd;
void *fshanp;
size_t fshlen;
char buffer[100];
if (argc != 2) {
fprintf(stderr, "usage: %s path\n", argv[0]);
exit(1);
}
Progname = argv[0];
(void)dm_init_service(&name);
if (dm_path_to_fshandle(argv[1], &fshanp, &fshlen) != 0) {
fprintf(stderr, "dm_path_to_fshandle failed, %s\n",
strerror(errno));
}
hantoa(fshanp, fshlen, buffer);
if ((fd = open(argv[1], O_RDONLY)) < 0) {
fprintf(stderr, "Open of %s failed, %s\n", argv[1],
strerror(errno));
exit(1);
}
fprintf(stdout, "fshandle %s, %s\n",
buffer, argv[1]);
exit(0);
}
int
main(
int argc,
char **argv)
{
#ifdef __sgi
xfs_fsop_geom_t geom;
char *uuid_str;
u_int status;
#endif
char *name;
int fd;
void *fshanp;
size_t fshlen;
char buffer[100];
if (argc != 2) {
fprintf(stderr, "usage: %s path\n", argv[0]);
exit(1);
}
Progname = argv[0];
(void)dm_init_service(&name);
if (dm_path_to_fshandle(argv[1], &fshanp, &fshlen) != 0) {
fprintf(stderr, "dm_path_to_fshandle failed, %s\n",
strerror(errno));
}
hantoa(fshanp, fshlen, buffer);
if ((fd = open(argv[1], O_RDONLY)) < 0) {
fprintf(stderr, "Open of %s failed, %s\n", argv[1],
strerror(errno));
exit(1);
}
#ifdef __sgi
syssgi(SGI_XFS_FSOPERATIONS, fd, XFS_FS_GEOMETRY, NULL, &geom);
uuid_to_string(&geom.uuid, &uuid_str, &status);
fprintf(stdout, "fshandle %s, uuid %s, %s\n",
buffer, uuid_str, argv[1]);
#endif
fprintf(stdout, "fshandle %s, %s\n",
buffer, argv[1]);
exit(0);
}
void
print_handle(
void *hanp,
size_t hlen)
{
char handle_str[HANDLE_STR];
if (hlen > HANDLE_LEN) {
printf("-- invalid hlen length %d --\n", hlen);
return;
}
printf("print_handle: ");
printf("%d\t", hlen);
hantoa(hanp, hlen, handle_str);
printf("%s\n ", handle_str);
}
void
my_print_victim(
dm_sessid_t sid,
void *hanp,
size_t hlen,
dm_attrname_t *dm_attrp,
int verbose)
{
size_t rlen;
size_t buflen = 10000;
char buf[buflen];
if (hlen > HANDLE_LEN) {
if (verbose & V_PRINT)
printf("-- invalid length --\n");
}
else {
char handle_str[HANDLE_STR];
if (verbose & V_PRINT) {
printf("%zd\t", hlen);
hantoa(hanp, hlen, handle_str);
printf("%s ", handle_str);
}
if (dm_get_dmattr(sid, hanp, hlen, DM_NO_TOKEN, dm_attrp,
buflen, (char*)buf, &rlen)) {
if (verbose & V_PRINT) {
if( errno == E2BIG ){
printf("E2BIG\n");
}
else if (errno == ENOMEM){
printf("ENOMEM\n");
}
else {
printf("<none>\n");
}
}
}
else if (verbose & V_PRINT) {
if( isalpha(buf[0]) )
printf("(%s)\n", buf);
else
printf("<len=%zd>\n",rlen);
}
}
}
void
print_victim(
void *hanp,
size_t hlen,
dm_off_t fsize)
{
char handle_str[HANDLE_STR];
if (hlen > HANDLE_LEN) {
printf("-- invalid length --\n");
return;
}
printf("%d\t", hlen);
hantoa(hanp, hlen, handle_str);
printf("%s ", handle_str);
printf("\t%lld \n", fsize);
}
int
main(
int argc,
char **argv)
{
char *han_str;
char *name;
void *hanp, *fshanp;
size_t hlen, fshlen;
char buffer[100];
int error;
if (Progname = strrchr(argv[0], '/')) {
Progname++;
} else {
Progname = argv[0];
}
if (argc != 2)
usage();
han_str = argv[1];
(void)dm_init_service(&name);
if ((error = atohan(han_str, &hanp, &hlen)) != 0) {
fprintf(stderr, "atohan() failed, %s\n", strerror(error));
return(1);
}
if (dm_handle_to_fshandle(hanp, hlen, &fshanp, &fshlen) != 0) {
fprintf(stderr, "dm_handle_to_fshandle failed, %s\n",
strerror(errno));
return(1);
}
hantoa(fshanp, fshlen, buffer);
fprintf(stdout, "%s\n", buffer);
dm_handle_free(hanp, hlen);
dm_handle_free(fshanp, fshlen);
return(0);
}
static int
print_one_data_event(
dm_data_event_t *msg_de)
{
char handle[HANDLE_STR];
void *hanp;
size_t hlen;
hanp = DM_GET_VALUE(msg_de, de_handle, void *);
hlen = DM_GET_LEN (msg_de, de_handle);
if (hanp && hlen) {
hantoa(hanp, hlen, handle);
} else {
sprintf(handle, "<BAD HANDLE, hlen %d>", hlen);
}
printf(VALS VALLLD VALLLD,
"file handle", handle,
"offset", msg_de->de_offset,
"length", msg_de->de_length);
return(0);
}
void
print_one_mount_event(
void *msg)
{
void *hanp1, *hanp2, *hanp3;
size_t hlen1, hlen2, hlen3;
char hans1[HANDLE_STR], hans2[HANDLE_STR], hans3[HANDLE_STR];
void *namp1, *namp2;
size_t nlen1, nlen2;
char nams1[NAME_MAX + 1], nams2[NAME_MAX + 1];
mode_t mode;
#if VERITAS
dm_namesp_event_t *msg_ne = (dm_namesp_event_t *)msg;
msg_ne = DM_GET_VALUE(msg, ev_data, dm_namesp_event_t *);
hanp1 = DM_GET_VALUE(msg_ne, ne_handle1, void *);
hlen1 = DM_GET_LEN (msg_ne, ne_handle1);
hanp2 = DM_GET_VALUE(msg_ne, ne_handle2, void *);
hlen2 = DM_GET_LEN (msg_ne, ne_handle2);
namp1 = DM_GET_VALUE(msg_ne, ne_name1, void *);
nlen1 = DM_GET_LEN (msg_ne, ne_name1);
namp2 = DM_GET_VALUE(msg_ne, ne_name2, void *);
nlen2 = DM_GET_LEN (msg_ne, ne_name2);
rootp = NULL;
rlen = 0;
mode = msg_ne->ne_mode;
#else
dm_mount_event_t *msg_me = (dm_mount_event_t *)msg;
hanp1 = DM_GET_VALUE(msg_me, me_handle1, void *);
hlen1 = DM_GET_LEN(msg_me, me_handle1);
hanp2 = DM_GET_VALUE(msg_me, me_handle2, void *);
hlen2 = DM_GET_LEN(msg_me, me_handle2);
namp1 = DM_GET_VALUE(msg_me, me_name1, void *);
nlen1 = DM_GET_LEN(msg_me, me_name1);
namp2 = DM_GET_VALUE(msg_me, me_name2, void *);
nlen2 = DM_GET_LEN(msg_me, me_name2);
hanp3 = DM_GET_VALUE(msg_me, me_roothandle, void *);
hlen3 = DM_GET_LEN(msg_me, me_roothandle);
mode = msg_me->me_mode;
#endif /* VERITAS */
if (hanp1 && hlen1) {
hantoa(hanp1, hlen1, hans1);
} else {
sprintf(hans1, "<BAD_HANDLE_hlen_%zd>", hlen1);
}
if (hanp2 && hlen2) {
hantoa(hanp2, hlen2, hans2);
} else {
sprintf(hans2, "<BAD_HANDLE_hlen_%zd>", hlen2);
}
if (hanp3 && hlen3) {
hantoa(hanp3, hlen3, hans3);
} else {
sprintf(hans3, "<BAD_HANDLE_hlen_%zd>", hlen3);
}
if (namp1 && nlen1) {
strncpy(nams1, namp1, nlen1);
if (nlen1 != sizeof(nams1))
nams1[nlen1] = '\0';
} else {
sprintf(nams1, "<BAD STRING_nlen_%zd>", nlen1);
}
if (namp2 && nlen2) {
strncpy(nams2, namp2, nlen2);
if (nlen2 != sizeof(nams2))
nams2[nlen2] = '\0';
} else {
sprintf(nams2, "<BAD_STRING_nlen_%zd>", nlen2);
}
printf(VALS VALS VALS VALS VALS VALD,
"fs handle", hans1,
"mtpt handle", hans2,
"mtpt path", nams1,
"media desig", nams2,
"root handle", hans3,
"mode", mode);
}
int
main(
int argc,
char **argv)
{
dm_sessid_t sid = DM_NO_SESSION;
dm_attrloc_t loc = 0;
char *dirpath;
char buffer[100];
void *bufp;
size_t buflen = 10000;
u_int mask;
size_t rlenp;
void *hanp;
size_t hlen;
char *name;
int opt;
int i;
int ret;
int oneline = 0;
int quiet = 0;
if (Progname = strrchr(argv[0], '/')) {
Progname++;
} else {
Progname = argv[0];
}
/* Crack and validate the command line options. */
while ((opt = getopt(argc, argv, "b:l:s:1q")) != EOF) {
switch (opt) {
case 'b':
buflen = atol(optarg);
break;
case 'l':
loc = atol(optarg);
break;
case 's':
sid = atol(optarg);
break;
case '1':
oneline = 1;
break;
case 'q':
quiet = 1;
break;
case '?':
usage();
}
}
if (optind + 1 != argc)
usage();
dirpath = argv[optind++];
if (dm_init_service(&name) == -1) {
fprintf(stderr, "Can't initialize the DMAPI\n");
exit(1);
}
if (sid == DM_NO_SESSION)
find_test_session(&sid);
/* Get the directory's handle. */
if (dm_path_to_handle(dirpath, &hanp, &hlen)) {
fprintf(stderr, "can't get handle for file %s, %s\n",
dirpath, strerror(errno));
exit(1);
}
if ((bufp = malloc(buflen == 0 ? 1 : buflen)) == NULL) {
fprintf(stderr, "malloc failed, %s\n", strerror(errno));
exit(1);
}
mask = DM_AT_HANDLE|DM_AT_EMASK|DM_AT_PMANR|DM_AT_PATTR|DM_AT_DTIME|DM_AT_CFLAG|DM_AT_STAT;
do {
memset(bufp, 0, buflen);
if ((ret = dm_get_dirattrs(sid, hanp, hlen, DM_NO_TOKEN, mask,
&loc, buflen, bufp, &rlenp)) < 0) {
fprintf(stderr, "dm_get_dirattrs failed, %s\n",
strerror(errno));
exit(1);
}
if (!quiet) {
fprintf(stdout, "ret = %d, rlenp is %d, loc is %lld\n", ret,
rlenp, loc);
}
if (rlenp > 0) {
dm_stat_t *statp;
statp = (dm_stat_t *)bufp;
while (statp != NULL) {
hantoa((char *)statp + statp->dt_handle.vd_offset,
statp->dt_handle.vd_length, buffer);
if (oneline) {
fprintf(stdout, "%s %s\n",
(char *)statp + statp->dt_compname.vd_offset,
buffer);
}
else {
fprintf(stdout, "handle %s\n", buffer);
fprintf(stdout, "name %s\n",
(char *)statp + statp->dt_compname.vd_offset);
print_line(statp);
}
statp = DM_STEP_TO_NEXT(statp, dm_stat_t *);
}
}
else if ((ret == 1) && (rlenp == 0) && (!quiet)) {
fprintf(stderr, "buflen is too short to hold anything\n");
exit(1);
}
} while (ret != 0);
int
main(
int argc,
char **argv)
{
char *pathname;
char *name;
void *hanp1, *hanp2, *hanp3, *fshanp1, *fshanp2, *fshanp3;
size_t hlen1, hlen2, hlen3, fshlen1, fshlen2, fshlen3;
u_int hash1, hash2, hash3, fshash1, fshash2, fshash3;
dm_fsid_t fsid;
dm_ino_t ino;
dm_igen_t igen;
char buffer[100];
char buffer1[100];
char fsbuffer1[100];
char buffer2[100];
char fsbuffer2[100];
char buffer3[100];
char fsbuffer3[100];
int fd;
if (Progname = strrchr(argv[0], '/')) {
Progname++;
} else {
Progname = argv[0];
}
if (argc != 2) {
fprintf(stderr, "usage: %s path\n", argv[0]);
exit(1);
}
pathname = argv[1];
(void)dm_init_service(&name);
if (dm_path_to_handle(pathname, &hanp1, &hlen1) != 0) {
fprintf(stderr, "dm_path_to_handle failed, %s\n",
strerror(errno));
exit(1);
}
hash1 = dm_handle_hash(hanp1, hlen1);
hantoa(hanp1, hlen1, buffer1);
fprintf(stdout, " han1: hash %u value %s (dm_path_to_handle)\n",
hash1, buffer1);
if (dm_handle_is_valid(hanp1, hlen1) == DM_FALSE) {
fprintf(stderr, "ERROR: han1 is not valid\n");
}
if (dm_path_to_fshandle(pathname, &fshanp1, &fshlen1) != 0) {
fprintf(stderr, "dm_path_to_fshandle failed, %s\n",
strerror(errno));
exit(1);
}
fshash1 = dm_handle_hash(fshanp1, fshlen1);
hantoa(fshanp1, fshlen1, fsbuffer1);
fprintf(stdout, "fshan1: hash %u value %s (dm_path_to_fshandle\n",
fshash1, fsbuffer1);
if (dm_handle_is_valid(fshanp1, fshlen1) == DM_FALSE) {
fprintf(stderr, "ERROR: fshan1 is not valid\n");
}
if ((fd = open(pathname, O_RDONLY)) < 0) {
fprintf(stderr, "open of %s failed, %s\n", pathname,
strerror(errno));
exit(1);
}
if (dm_fd_to_handle(fd, &hanp2, &hlen2) != 0) {
fprintf(stderr, "dm_fd_to_handle failed, %s\n",
strerror(errno));
exit(1);
}
(void)close(fd);
hash2 = dm_handle_hash(hanp2, hlen2);
hantoa(hanp2, hlen2, buffer2);
fprintf(stdout, " han2: hash %u value %s (dm_fd_to_handle)\n",
hash2, buffer2);
if (dm_handle_is_valid(hanp2, hlen2) == DM_FALSE) {
fprintf(stderr, "ERROR: han2 is not valid\n");
}
if (dm_handle_to_fshandle(hanp2, hlen2, &fshanp2, &fshlen2) != 0) {
fprintf(stderr, "dm_handle_to_fshandle failed, %s\n",
strerror(errno));
exit(1);
}
fshash2 = dm_handle_hash(fshanp2, fshlen2);
hantoa(fshanp2, fshlen2, fsbuffer2);
fprintf(stdout, "fshan2: hash %u value %s (dm_handle_to_fshandle)\n",
fshash2, fsbuffer2);
if (dm_handle_is_valid(fshanp2, fshlen2) == DM_FALSE) {
fprintf(stderr, "ERROR: fshan2 is not valid\n");
}
if (dm_handle_cmp(hanp1, hlen1, hanp2, hlen2)) {
fprintf(stderr, "ERROR: han1 and han2 differ in dm_handle_cmp\n");
}
if (strcmp(buffer1, buffer2)) {
fprintf(stderr, "ERROR: han1 and han2 differ in strcmp\n");
}
if (hash1 != hash2) {
fprintf(stderr, "ERROR: hash1 and hash2 differ\n");
}
if (dm_handle_cmp(fshanp1, fshlen1, fshanp2, fshlen2)) {
fprintf(stderr, "ERROR: fshan1 and fshan2 differ in dm_handle_cmp\n");
}
if (strcmp(fsbuffer1, fsbuffer2)) {
fprintf(stderr, "ERROR: fshan1 and fshan2 differ in strcmp\n");
}
if (fshash1 != fshash2) {
fprintf(stderr, "ERROR: fshash1 and fshash2 differ\n");
}
/* Break the handle into its component parts and display them. Use
hantoa() instead of printing the parts directly because some are
32 bits on Veritas and 64 bits on SGI.
*/
if (dm_handle_to_fsid(hanp1, hlen1, &fsid) != 0) {
fprintf(stderr, "dm_handle_to_fsid failed, %s\n",
strerror(errno));
exit(1);
}
hantoa(&fsid, sizeof(fsid), buffer);
fprintf(stdout, "fsid %s (dm_handle_to_fsid)\n", buffer);
if (dm_handle_to_ino(hanp1, hlen1, &ino) != 0) {
fprintf(stderr, "dm_handle_to_ino failed, %s\n",
strerror(errno));
exit(1);
}
hantoa(&ino, sizeof(ino), buffer);
fprintf(stdout, "ino %s (dm_handle_to_ino)\n", buffer);
if (dm_handle_to_igen(hanp1, hlen1, &igen) != 0) {
fprintf(stderr, "dm_handle_to_igen failed, %s\n",
strerror(errno));
exit(1);
}
hantoa(&igen, sizeof(igen), buffer);
fprintf(stdout, "igen %s (dm_handle_to_igen)\n", buffer);
/* Now use the parts to remake the handle and verify we get the same
answer.
*/
if (dm_make_handle(&fsid, &ino, &igen, &hanp3, &hlen3) != 0) {
fprintf(stderr, "dm_make_handle failed, %s\n",
strerror(errno));
exit(1);
}
hash3 = dm_handle_hash(hanp3, hlen3);
hantoa(hanp3, hlen3, buffer3);
fprintf(stdout, " han3: hash %u value %s (dm_make_handle)\n",
hash3, buffer3);
if (dm_handle_is_valid(hanp3, hlen3) == DM_FALSE) {
fprintf(stderr, "ERROR: han3 is not valid\n");
}
if (dm_handle_cmp(hanp1, hlen1, hanp3, hlen3)) {
fprintf(stderr, "ERROR: hanp1 and hanp3 differ in dm_handle_cmp\n");
}
if (strcmp(buffer1, buffer3)) {
fprintf(stderr, "ERROR: hanp1 and hanp3 differ in strcmp\n");
}
if (hash1 != hash3) {
fprintf(stderr, "ERROR: hash1 and hash3 differ\n");
}
if (dm_make_fshandle(&fsid, &fshanp3, &fshlen3) != 0) {
fprintf(stderr, "dm_make_fshandle failed, %s\n",
strerror(errno));
exit(1);
}
fshash3 = dm_handle_hash(fshanp3, fshlen3);
hantoa(fshanp3, fshlen3, fsbuffer3);
fprintf(stdout, "fshan3: hash %u value %s (dm_make_fshandle)\n",
fshash3, fsbuffer3);
if (dm_handle_is_valid(fshanp3, fshlen3) == DM_FALSE) {
fprintf(stderr, "ERROR: fshan3 is not valid\n");
}
if (dm_handle_cmp(fshanp1, fshlen1, fshanp3, fshlen3)) {
fprintf(stderr, "ERROR: fshan1 and fshan3 differ in dm_handle_cmp\n");
}
if (strcmp(fsbuffer1, fsbuffer3)) {
fprintf(stderr, "ERROR: fshan1 and fshan3 differ in strcmp\n");
}
if (fshash1 != fshash3) {
fprintf(stderr, "ERROR: fshash1 and fshash3 differ\n");
}
dm_handle_free(hanp1, hlen1);
dm_handle_free(hanp2, hlen2);
dm_handle_free(hanp3, hlen3);
dm_handle_free(fshanp1, fshlen1);
dm_handle_free(fshanp2, fshlen2);
dm_handle_free(fshanp3, fshlen3);
exit(0);
}
