00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "includes.h"
00024 #include "vfstest.h"
00025
00026 static const char *null_string = "";
00027
00028 static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00029 {
00030 int i;
00031
00032 if (argc < 2) {
00033 printf("Usage: load <modules>\n");
00034 return NT_STATUS_OK;
00035 }
00036
00037 for (i=argc-1;i>0;i--) {
00038 if (!vfs_init_custom(vfs->conn, argv[i])) {
00039 DEBUG(0, ("load: (vfs_init_custom failed for %s)\n", argv[i]));
00040 return NT_STATUS_UNSUCCESSFUL;
00041 }
00042 }
00043 printf("load: ok\n");
00044 return NT_STATUS_OK;
00045 }
00046
00047 static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00048 {
00049 char c;
00050 size_t size;
00051 if (argc != 3) {
00052 printf("Usage: populate <char> <size>\n");
00053 return NT_STATUS_OK;
00054 }
00055 c = argv[1][0];
00056 size = atoi(argv[2]);
00057 vfs->data = TALLOC_ARRAY(mem_ctx, char, size);
00058 if (vfs->data == NULL) {
00059 printf("populate: error=-1 (not enough memory)");
00060 return NT_STATUS_UNSUCCESSFUL;
00061 }
00062 memset(vfs->data, c, size);
00063 vfs->data_size = size;
00064 return NT_STATUS_OK;
00065 }
00066
00067 static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00068 {
00069 size_t offset;
00070 size_t len;
00071 if (argc != 1 && argc != 3) {
00072 printf("Usage: showdata [<offset> <len>]\n");
00073 return NT_STATUS_OK;
00074 }
00075 if (vfs->data == NULL || vfs->data_size == 0) {
00076 printf("show_data: error=-1 (buffer empty)\n");
00077 return NT_STATUS_UNSUCCESSFUL;
00078 }
00079
00080 if (argc == 3) {
00081 offset = atoi(argv[1]);
00082 len = atoi(argv[2]);
00083 } else {
00084 offset = 0;
00085 len = vfs->data_size;
00086 }
00087 if ((offset + len) > vfs->data_size) {
00088 printf("show_data: error=-1 (not enough data in buffer)\n");
00089 return NT_STATUS_UNSUCCESSFUL;
00090 }
00091 dump_data(0, (char *)(vfs->data) + offset, len);
00092 return NT_STATUS_OK;
00093 }
00094
00095 static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00096 {
00097 SMB_VFS_CONNECT(vfs->conn, lp_servicename(SNUM(vfs->conn)), "vfstest");
00098 return NT_STATUS_OK;
00099 }
00100
00101 static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00102 {
00103 SMB_VFS_DISCONNECT(vfs->conn);
00104 return NT_STATUS_OK;
00105 }
00106
00107 static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00108 {
00109 SMB_BIG_UINT diskfree, bsize, dfree, dsize;
00110 if (argc != 2) {
00111 printf("Usage: disk_free <path>\n");
00112 return NT_STATUS_OK;
00113 }
00114
00115 diskfree = SMB_VFS_DISK_FREE(vfs->conn, argv[1], False, &bsize, &dfree, &dsize);
00116 printf("disk_free: %lu, bsize = %lu, dfree = %lu, dsize = %lu\n",
00117 (unsigned long)diskfree,
00118 (unsigned long)bsize,
00119 (unsigned long)dfree,
00120 (unsigned long)dsize);
00121 return NT_STATUS_OK;
00122 }
00123
00124
00125 static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00126 {
00127 if (argc != 2) {
00128 printf("Usage: opendir <fname>\n");
00129 return NT_STATUS_OK;
00130 }
00131
00132 vfs->currentdir = SMB_VFS_OPENDIR(vfs->conn, argv[1], NULL, 0);
00133 if (vfs->currentdir == NULL) {
00134 printf("opendir error=%d (%s)\n", errno, strerror(errno));
00135 return NT_STATUS_UNSUCCESSFUL;
00136 }
00137
00138 printf("opendir: ok\n");
00139 return NT_STATUS_OK;
00140 }
00141
00142
00143 static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00144 {
00145 SMB_STRUCT_DIRENT *dent;
00146
00147 if (vfs->currentdir == NULL) {
00148 printf("readdir: error=-1 (no open directory)\n");
00149 return NT_STATUS_UNSUCCESSFUL;
00150 }
00151
00152 dent = SMB_VFS_READDIR(vfs->conn, vfs->currentdir);
00153 if (dent == NULL) {
00154 printf("readdir: NULL\n");
00155 return NT_STATUS_OK;
00156 }
00157
00158 printf("readdir: %s\n", dent->d_name);
00159 return NT_STATUS_OK;
00160 }
00161
00162
00163 static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00164 {
00165 if (argc != 2) {
00166 printf("Usage: mkdir <path>\n");
00167 return NT_STATUS_OK;
00168 }
00169
00170 if (SMB_VFS_MKDIR(vfs->conn, argv[1], 00755) == -1) {
00171 printf("mkdir error=%d (%s)\n", errno, strerror(errno));
00172 return NT_STATUS_UNSUCCESSFUL;
00173 }
00174
00175 printf("mkdir: ok\n");
00176 return NT_STATUS_OK;
00177 }
00178
00179
00180 static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00181 {
00182 int ret;
00183
00184 if (vfs->currentdir == NULL) {
00185 printf("closedir: failure (no directory open)\n");
00186 return NT_STATUS_UNSUCCESSFUL;
00187 }
00188
00189 ret = SMB_VFS_CLOSEDIR(vfs->conn, vfs->currentdir);
00190 if (ret == -1) {
00191 printf("closedir failure: %s\n", strerror(errno));
00192 return NT_STATUS_UNSUCCESSFUL;
00193 }
00194
00195 printf("closedir: ok\n");
00196 vfs->currentdir = NULL;
00197 return NT_STATUS_OK;
00198 }
00199
00200
00201 static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00202 {
00203 int flags;
00204 mode_t mode;
00205 const char *flagstr;
00206 files_struct *fsp;
00207
00208 mode = 00400;
00209
00210 if (argc < 3 || argc > 5) {
00211 printf("Usage: open <filename> <flags> <mode>\n");
00212 printf(" flags: O = O_RDONLY\n");
00213 printf(" R = O_RDWR\n");
00214 printf(" W = O_WRONLY\n");
00215 printf(" C = O_CREAT\n");
00216 printf(" E = O_EXCL\n");
00217 printf(" T = O_TRUNC\n");
00218 printf(" A = O_APPEND\n");
00219 printf(" N = O_NONBLOCK/O_NDELAY\n");
00220 #ifdef O_SYNC
00221 printf(" S = O_SYNC\n");
00222 #endif
00223 #ifdef O_NOFOLLOW
00224 printf(" F = O_NOFOLLOW\n");
00225 #endif
00226 printf(" mode: see open.2\n");
00227 printf(" mode is ignored if C flag not present\n");
00228 printf(" mode defaults to 00400\n");
00229 return NT_STATUS_OK;
00230 }
00231 flags = 0;
00232 flagstr = argv[2];
00233 while (*flagstr) {
00234 switch (*flagstr) {
00235 case 'O':
00236 flags |= O_RDONLY;
00237 break;
00238 case 'R':
00239 flags |= O_RDWR;
00240 break;
00241 case 'W':
00242 flags |= O_WRONLY;
00243 break;
00244 case 'C':
00245 flags |= O_CREAT;
00246 break;
00247 case 'E':
00248 flags |= O_EXCL;
00249 break;
00250 case 'T':
00251 flags |= O_TRUNC;
00252 break;
00253 case 'A':
00254 flags |= O_APPEND;
00255 break;
00256 case 'N':
00257 flags |= O_NONBLOCK;
00258 break;
00259 #ifdef O_SYNC
00260 case 'S':
00261 flags |= O_SYNC;
00262 break;
00263 #endif
00264 #ifdef O_NOFOLLOW
00265 case 'F':
00266 flags |= O_NOFOLLOW;
00267 break;
00268 #endif
00269 default:
00270 printf("open: error=-1 (invalid flag!)\n");
00271 return NT_STATUS_UNSUCCESSFUL;
00272 }
00273 flagstr++;
00274 }
00275 if ((flags & O_CREAT) && argc == 4) {
00276 if (sscanf(argv[3], "%o", &mode) == 0) {
00277 printf("open: error=-1 (invalid mode!)\n");
00278 return NT_STATUS_UNSUCCESSFUL;
00279 }
00280 }
00281
00282 fsp = SMB_MALLOC_P(struct files_struct);
00283 fsp->fsp_name = SMB_STRDUP(argv[1]);
00284 fsp->fh = SMB_MALLOC_P(struct fd_handle);
00285 fsp->conn = vfs->conn;
00286
00287 fsp->fh->fd = SMB_VFS_OPEN(vfs->conn, argv[1], fsp, flags, mode);
00288 if (fsp->fh->fd == -1) {
00289 printf("open: error=%d (%s)\n", errno, strerror(errno));
00290 SAFE_FREE(fsp->fh);
00291 SAFE_FREE(fsp);
00292 return NT_STATUS_UNSUCCESSFUL;
00293 }
00294
00295 vfs->files[fsp->fh->fd] = fsp;
00296 printf("open: fd=%d\n", fsp->fh->fd);
00297 return NT_STATUS_OK;
00298 }
00299
00300
00301 static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00302 {
00303 int ret = -1;
00304
00305 if (argc != 2) {
00306 printf("Usage: %s <path>\n", argv[0]);
00307 return NT_STATUS_OK;
00308 }
00309
00310 if (strcmp("rmdir", argv[0]) == 0 ) {
00311 ret = SMB_VFS_RMDIR(vfs->conn, argv[1]);
00312 } else if (strcmp("unlink", argv[0]) == 0 ) {
00313 ret = SMB_VFS_UNLINK(vfs->conn, argv[1]);
00314 } else if (strcmp("chdir", argv[0]) == 0 ) {
00315 ret = SMB_VFS_CHDIR(vfs->conn, argv[1]);
00316 } else {
00317 printf("%s: error=%d (invalid function name!)\n", argv[0], errno);
00318 return NT_STATUS_UNSUCCESSFUL;
00319 }
00320
00321 if (ret == -1) {
00322 printf("%s: error=%d (%s)\n", argv[0], errno, strerror(errno));
00323 return NT_STATUS_UNSUCCESSFUL;
00324 }
00325
00326 printf("%s: ok\n", argv[0]);
00327 return NT_STATUS_OK;
00328 }
00329
00330
00331 static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00332 {
00333 int fd, ret;
00334
00335 if (argc != 2) {
00336 printf("Usage: close <fd>\n");
00337 return NT_STATUS_OK;
00338 }
00339
00340 fd = atoi(argv[1]);
00341 if (vfs->files[fd] == NULL) {
00342 printf("close: error=-1 (invalid file descriptor)\n");
00343 return NT_STATUS_OK;
00344 }
00345
00346 ret = SMB_VFS_CLOSE(vfs->files[fd], fd);
00347 if (ret == -1 )
00348 printf("close: error=%d (%s)\n", errno, strerror(errno));
00349 else
00350 printf("close: ok\n");
00351
00352 SAFE_FREE(vfs->files[fd]->fsp_name);
00353 SAFE_FREE(vfs->files[fd]->fh);
00354 SAFE_FREE(vfs->files[fd]);
00355 vfs->files[fd] = NULL;
00356 return NT_STATUS_OK;
00357 }
00358
00359
00360 static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00361 {
00362 int fd;
00363 size_t size, rsize;
00364
00365 if (argc != 3) {
00366 printf("Usage: read <fd> <size>\n");
00367 return NT_STATUS_OK;
00368 }
00369
00370
00371 fd = atoi(argv[1]);
00372 size = atoi(argv[2]);
00373 vfs->data = TALLOC_ARRAY(mem_ctx, char, size);
00374 if (vfs->data == NULL) {
00375 printf("read: error=-1 (not enough memory)");
00376 return NT_STATUS_UNSUCCESSFUL;
00377 }
00378 vfs->data_size = size;
00379
00380 rsize = SMB_VFS_READ(vfs->files[fd], fd, vfs->data, size);
00381 if (rsize == -1) {
00382 printf("read: error=%d (%s)\n", errno, strerror(errno));
00383 return NT_STATUS_UNSUCCESSFUL;
00384 }
00385
00386 printf("read: ok\n");
00387 return NT_STATUS_OK;
00388 }
00389
00390
00391 static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00392 {
00393 int fd, size, wsize;
00394
00395 if (argc != 3) {
00396 printf("Usage: write <fd> <size>\n");
00397 return NT_STATUS_OK;
00398 }
00399
00400
00401 fd = atoi(argv[1]);
00402 size = atoi(argv[2]);
00403 if (vfs->data == NULL) {
00404 printf("write: error=-1 (buffer empty, please populate it before writing)");
00405 return NT_STATUS_UNSUCCESSFUL;
00406 }
00407
00408 if (vfs->data_size < size) {
00409 printf("write: error=-1 (buffer too small, please put some more data in)");
00410 return NT_STATUS_UNSUCCESSFUL;
00411 }
00412
00413 wsize = SMB_VFS_WRITE(vfs->files[fd], fd, vfs->data, size);
00414
00415 if (wsize == -1) {
00416 printf("write: error=%d (%s)\n", errno, strerror(errno));
00417 return NT_STATUS_UNSUCCESSFUL;
00418 }
00419
00420 printf("write: ok\n");
00421 return NT_STATUS_OK;
00422 }
00423
00424
00425 static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00426 {
00427 int fd, offset, whence;
00428 SMB_OFF_T pos;
00429
00430 if (argc != 4) {
00431 printf("Usage: lseek <fd> <offset> <whence>\n...where whence is 1 => SEEK_SET, 2 => SEEK_CUR, 3 => SEEK_END\n");
00432 return NT_STATUS_OK;
00433 }
00434
00435 fd = atoi(argv[1]);
00436 offset = atoi(argv[2]);
00437 whence = atoi(argv[3]);
00438 switch (whence) {
00439 case 1: whence = SEEK_SET; break;
00440 case 2: whence = SEEK_CUR; break;
00441 default: whence = SEEK_END;
00442 }
00443
00444 pos = SMB_VFS_LSEEK(vfs->files[fd], fd, offset, whence);
00445 if (pos == (SMB_OFF_T)-1) {
00446 printf("lseek: error=%d (%s)\n", errno, strerror(errno));
00447 return NT_STATUS_UNSUCCESSFUL;
00448 }
00449
00450 printf("lseek: ok\n");
00451 return NT_STATUS_OK;
00452 }
00453
00454
00455 static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00456 {
00457 int ret;
00458 if (argc != 3) {
00459 printf("Usage: rename <old> <new>\n");
00460 return NT_STATUS_OK;
00461 }
00462
00463 ret = SMB_VFS_RENAME(vfs->conn, argv[1], argv[2]);
00464 if (ret == -1) {
00465 printf("rename: error=%d (%s)\n", errno, strerror(errno));
00466 return NT_STATUS_UNSUCCESSFUL;
00467 }
00468
00469 printf("rename: ok\n");
00470 return NT_STATUS_OK;
00471 }
00472
00473
00474 static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00475 {
00476 int ret, fd;
00477 if (argc != 2) {
00478 printf("Usage: fsync <fd>\n");
00479 return NT_STATUS_OK;
00480 }
00481
00482 fd = atoi(argv[1]);
00483 ret = SMB_VFS_FSYNC(vfs->files[fd], fd);
00484 if (ret == -1) {
00485 printf("fsync: error=%d (%s)\n", errno, strerror(errno));
00486 return NT_STATUS_UNSUCCESSFUL;
00487 }
00488
00489 printf("fsync: ok\n");
00490 return NT_STATUS_OK;
00491 }
00492
00493
00494 static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00495 {
00496 int ret;
00497 const char *user;
00498 const char *group;
00499 struct passwd *pwd = NULL;
00500 struct group *grp = NULL;
00501 SMB_STRUCT_STAT st;
00502
00503 if (argc != 2) {
00504 printf("Usage: stat <fname>\n");
00505 return NT_STATUS_OK;
00506 }
00507
00508 ret = SMB_VFS_STAT(vfs->conn, argv[1], &st);
00509 if (ret == -1) {
00510 printf("stat: error=%d (%s)\n", errno, strerror(errno));
00511 return NT_STATUS_UNSUCCESSFUL;
00512 }
00513
00514 pwd = sys_getpwuid(st.st_uid);
00515 if (pwd != NULL) user = pwd->pw_name;
00516 else user = null_string;
00517 grp = sys_getgrgid(st.st_gid);
00518 if (grp != NULL) group = grp->gr_name;
00519 else group = null_string;
00520
00521 printf("stat: ok\n");
00522 printf(" File: %s", argv[1]);
00523 if (S_ISREG(st.st_mode)) printf(" Regular File\n");
00524 else if (S_ISDIR(st.st_mode)) printf(" Directory\n");
00525 else if (S_ISCHR(st.st_mode)) printf(" Character Device\n");
00526 else if (S_ISBLK(st.st_mode)) printf(" Block Device\n");
00527 else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n");
00528 else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n");
00529 else if (S_ISSOCK(st.st_mode)) printf(" Socket\n");
00530 printf(" Size: %10u", (unsigned int)st.st_size);
00531 #ifdef HAVE_STAT_ST_BLOCKS
00532 printf(" Blocks: %9u", (unsigned int)st.st_blocks);
00533 #endif
00534 #ifdef HAVE_STAT_ST_BLKSIZE
00535 printf(" IO Block: %u\n", (unsigned int)st.st_blksize);
00536 #endif
00537 printf(" Device: 0x%10x", (unsigned int)st.st_dev);
00538 printf(" Inode: %10u", (unsigned int)st.st_ino);
00539 printf(" Links: %10u\n", (unsigned int)st.st_nlink);
00540 printf(" Access: %05o", (st.st_mode) & 007777);
00541 printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_uid, user,
00542 (unsigned long)st.st_gid, group);
00543 printf(" Access: %s", ctime(&(st.st_atime)));
00544 printf(" Modify: %s", ctime(&(st.st_mtime)));
00545 printf(" Change: %s", ctime(&(st.st_ctime)));
00546
00547 return NT_STATUS_OK;
00548 }
00549
00550
00551 static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00552 {
00553 int fd;
00554 const char *user;
00555 const char *group;
00556 struct passwd *pwd = NULL;
00557 struct group *grp = NULL;
00558 SMB_STRUCT_STAT st;
00559
00560 if (argc != 2) {
00561 printf("Usage: fstat <fd>\n");
00562 return NT_STATUS_OK;
00563 }
00564
00565 fd = atoi(argv[1]);
00566 if (fd < 0 || fd > 1024) {
00567 printf("fstat: error=%d (file descriptor out of range)\n", EBADF);
00568 return NT_STATUS_OK;
00569 }
00570
00571 if (vfs->files[fd] == NULL) {
00572 printf("fstat: error=%d (invalid file descriptor)\n", EBADF);
00573 return NT_STATUS_OK;
00574 }
00575
00576 if (SMB_VFS_FSTAT(vfs->files[fd], fd, &st) == -1) {
00577 printf("fstat: error=%d (%s)\n", errno, strerror(errno));
00578 return NT_STATUS_UNSUCCESSFUL;
00579 }
00580
00581 pwd = sys_getpwuid(st.st_uid);
00582 if (pwd != NULL) user = pwd->pw_name;
00583 else user = null_string;
00584 grp = sys_getgrgid(st.st_gid);
00585 if (grp != NULL) group = grp->gr_name;
00586 else group = null_string;
00587
00588 printf("fstat: ok\n");
00589 if (S_ISREG(st.st_mode)) printf(" Regular File\n");
00590 else if (S_ISDIR(st.st_mode)) printf(" Directory\n");
00591 else if (S_ISCHR(st.st_mode)) printf(" Character Device\n");
00592 else if (S_ISBLK(st.st_mode)) printf(" Block Device\n");
00593 else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n");
00594 else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n");
00595 else if (S_ISSOCK(st.st_mode)) printf(" Socket\n");
00596 printf(" Size: %10u", (unsigned int)st.st_size);
00597 #ifdef HAVE_STAT_ST_BLOCKS
00598 printf(" Blocks: %9u", (unsigned int)st.st_blocks);
00599 #endif
00600 #ifdef HAVE_STAT_ST_BLKSIZE
00601 printf(" IO Block: %u\n", (unsigned int)st.st_blksize);
00602 #endif
00603 printf(" Device: 0x%10x", (unsigned int)st.st_dev);
00604 printf(" Inode: %10u", (unsigned int)st.st_ino);
00605 printf(" Links: %10u\n", (unsigned int)st.st_nlink);
00606 printf(" Access: %05o", (st.st_mode) & 007777);
00607 printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_uid, user,
00608 (unsigned long)st.st_gid, group);
00609 printf(" Access: %s", ctime(&(st.st_atime)));
00610 printf(" Modify: %s", ctime(&(st.st_mtime)));
00611 printf(" Change: %s", ctime(&(st.st_ctime)));
00612
00613 return NT_STATUS_OK;
00614 }
00615
00616
00617 static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00618 {
00619 const char *user;
00620 const char *group;
00621 struct passwd *pwd = NULL;
00622 struct group *grp = NULL;
00623 SMB_STRUCT_STAT st;
00624
00625 if (argc != 2) {
00626 printf("Usage: lstat <path>\n");
00627 return NT_STATUS_OK;
00628 }
00629
00630 if (SMB_VFS_LSTAT(vfs->conn, argv[1], &st) == -1) {
00631 printf("lstat: error=%d (%s)\n", errno, strerror(errno));
00632 return NT_STATUS_UNSUCCESSFUL;
00633 }
00634
00635 pwd = sys_getpwuid(st.st_uid);
00636 if (pwd != NULL) user = pwd->pw_name;
00637 else user = null_string;
00638 grp = sys_getgrgid(st.st_gid);
00639 if (grp != NULL) group = grp->gr_name;
00640 else group = null_string;
00641
00642 printf("lstat: ok\n");
00643 if (S_ISREG(st.st_mode)) printf(" Regular File\n");
00644 else if (S_ISDIR(st.st_mode)) printf(" Directory\n");
00645 else if (S_ISCHR(st.st_mode)) printf(" Character Device\n");
00646 else if (S_ISBLK(st.st_mode)) printf(" Block Device\n");
00647 else if (S_ISFIFO(st.st_mode)) printf(" Fifo\n");
00648 else if (S_ISLNK(st.st_mode)) printf(" Symbolic Link\n");
00649 else if (S_ISSOCK(st.st_mode)) printf(" Socket\n");
00650 printf(" Size: %10u", (unsigned int)st.st_size);
00651 #ifdef HAVE_STAT_ST_BLOCKS
00652 printf(" Blocks: %9u", (unsigned int)st.st_blocks);
00653 #endif
00654 #ifdef HAVE_STAT_ST_BLKSIZE
00655 printf(" IO Block: %u\n", (unsigned int)st.st_blksize);
00656 #endif
00657 printf(" Device: 0x%10x", (unsigned int)st.st_dev);
00658 printf(" Inode: %10u", (unsigned int)st.st_ino);
00659 printf(" Links: %10u\n", (unsigned int)st.st_nlink);
00660 printf(" Access: %05o", (st.st_mode) & 007777);
00661 printf(" Uid: %5lu/%.16s Gid: %5lu/%.16s\n", (unsigned long)st.st_uid, user,
00662 (unsigned long)st.st_gid, group);
00663 printf(" Access: %s", ctime(&(st.st_atime)));
00664 printf(" Modify: %s", ctime(&(st.st_mtime)));
00665 printf(" Change: %s", ctime(&(st.st_ctime)));
00666
00667 return NT_STATUS_OK;
00668 }
00669
00670
00671 static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00672 {
00673 mode_t mode;
00674 if (argc != 3) {
00675 printf("Usage: chmod <path> <mode>\n");
00676 return NT_STATUS_OK;
00677 }
00678
00679 mode = atoi(argv[2]);
00680 if (SMB_VFS_CHMOD(vfs->conn, argv[1], mode) == -1) {
00681 printf("chmod: error=%d (%s)\n", errno, strerror(errno));
00682 return NT_STATUS_UNSUCCESSFUL;
00683 }
00684
00685 printf("chmod: ok\n");
00686 return NT_STATUS_OK;
00687 }
00688
00689
00690 static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00691 {
00692 int fd;
00693 mode_t mode;
00694 if (argc != 3) {
00695 printf("Usage: fchmod <fd> <mode>\n");
00696 return NT_STATUS_OK;
00697 }
00698
00699 fd = atoi(argv[1]);
00700 mode = atoi(argv[2]);
00701 if (fd < 0 || fd > 1024) {
00702 printf("fchmod: error=%d (file descriptor out of range)\n", EBADF);
00703 return NT_STATUS_OK;
00704 }
00705 if (vfs->files[fd] == NULL) {
00706 printf("fchmod: error=%d (invalid file descriptor)\n", EBADF);
00707 return NT_STATUS_OK;
00708 }
00709
00710 if (SMB_VFS_FCHMOD(vfs->files[fd], fd, mode) == -1) {
00711 printf("fchmod: error=%d (%s)\n", errno, strerror(errno));
00712 return NT_STATUS_UNSUCCESSFUL;
00713 }
00714
00715 printf("fchmod: ok\n");
00716 return NT_STATUS_OK;
00717 }
00718
00719
00720 static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00721 {
00722 uid_t uid;
00723 gid_t gid;
00724 if (argc != 4) {
00725 printf("Usage: chown <path> <uid> <gid>\n");
00726 return NT_STATUS_OK;
00727 }
00728
00729 uid = atoi(argv[2]);
00730 gid = atoi(argv[3]);
00731 if (SMB_VFS_CHOWN(vfs->conn, argv[1], uid, gid) == -1) {
00732 printf("chown: error=%d (%s)\n", errno, strerror(errno));
00733 return NT_STATUS_UNSUCCESSFUL;
00734 }
00735
00736 printf("chown: ok\n");
00737 return NT_STATUS_OK;
00738 }
00739
00740
00741 static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00742 {
00743 uid_t uid;
00744 gid_t gid;
00745 int fd;
00746 if (argc != 4) {
00747 printf("Usage: fchown <fd> <uid> <gid>\n");
00748 return NT_STATUS_OK;
00749 }
00750
00751 uid = atoi(argv[2]);
00752 gid = atoi(argv[3]);
00753 fd = atoi(argv[1]);
00754 if (fd < 0 || fd > 1024) {
00755 printf("fchown: faliure=%d (file descriptor out of range)\n", EBADF);
00756 return NT_STATUS_OK;
00757 }
00758 if (vfs->files[fd] == NULL) {
00759 printf("fchown: error=%d (invalid file descriptor)\n", EBADF);
00760 return NT_STATUS_OK;
00761 }
00762 if (SMB_VFS_FCHOWN(vfs->files[fd], fd, uid, gid) == -1) {
00763 printf("fchown error=%d (%s)\n", errno, strerror(errno));
00764 return NT_STATUS_UNSUCCESSFUL;
00765 }
00766
00767 printf("fchown: ok\n");
00768 return NT_STATUS_OK;
00769 }
00770
00771
00772 static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00773 {
00774 char buf[PATH_MAX];
00775 if (SMB_VFS_GETWD(vfs->conn, buf) == NULL) {
00776 printf("getwd: error=%d (%s)\n", errno, strerror(errno));
00777 return NT_STATUS_UNSUCCESSFUL;
00778 }
00779
00780 printf("getwd: %s\n", buf);
00781 return NT_STATUS_OK;
00782 }
00783
00784 static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00785 {
00786 struct timespec ts[2];
00787 if (argc != 4) {
00788 printf("Usage: utime <path> <access> <modify>\n");
00789 return NT_STATUS_OK;
00790 }
00791 ts[0] = convert_time_t_to_timespec(atoi(argv[2]));
00792 ts[1] = convert_time_t_to_timespec(atoi(argv[3]));
00793 if (SMB_VFS_NTIMES(vfs->conn, argv[1], ts) != 0) {
00794 printf("utime: error=%d (%s)\n", errno, strerror(errno));
00795 return NT_STATUS_UNSUCCESSFUL;
00796 }
00797
00798 printf("utime: ok\n");
00799 return NT_STATUS_OK;
00800 }
00801
00802 static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00803 {
00804 int fd;
00805 SMB_OFF_T off;
00806 if (argc != 3) {
00807 printf("Usage: ftruncate <fd> <length>\n");
00808 return NT_STATUS_OK;
00809 }
00810
00811 fd = atoi(argv[1]);
00812 off = atoi(argv[2]);
00813 if (fd < 0 || fd > 1024) {
00814 printf("ftruncate: error=%d (file descriptor out of range)\n", EBADF);
00815 return NT_STATUS_OK;
00816 }
00817 if (vfs->files[fd] == NULL) {
00818 printf("ftruncate: error=%d (invalid file descriptor)\n", EBADF);
00819 return NT_STATUS_OK;
00820 }
00821
00822 if (SMB_VFS_FTRUNCATE(vfs->files[fd], fd, off) == -1) {
00823 printf("ftruncate: error=%d (%s)\n", errno, strerror(errno));
00824 return NT_STATUS_UNSUCCESSFUL;
00825 }
00826
00827 printf("ftruncate: ok\n");
00828 return NT_STATUS_OK;
00829 }
00830
00831 static NTSTATUS cmd_lock(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00832 {
00833 BOOL ret;
00834 int fd;
00835 int op;
00836 long offset;
00837 long count;
00838 int type;
00839 const char *typestr;
00840
00841 if (argc != 6) {
00842 printf("Usage: lock <fd> <op> <offset> <count> <type>\n");
00843 printf(" ops: G = F_GETLK\n");
00844 printf(" S = F_SETLK\n");
00845 printf(" W = F_SETLKW\n");
00846 printf(" type: R = F_RDLCK\n");
00847 printf(" W = F_WRLCK\n");
00848 printf(" U = F_UNLCK\n");
00849 return NT_STATUS_OK;
00850 }
00851
00852 if (sscanf(argv[1], "%d", &fd) == 0) {
00853 printf("lock: error=-1 (error parsing fd)\n");
00854 return NT_STATUS_UNSUCCESSFUL;
00855 }
00856
00857 op = 0;
00858 switch (*argv[2]) {
00859 case 'G':
00860 op = F_GETLK;
00861 break;
00862 case 'S':
00863 op = F_SETLK;
00864 break;
00865 case 'W':
00866 op = F_SETLKW;
00867 break;
00868 default:
00869 printf("lock: error=-1 (invalid op flag!)\n");
00870 return NT_STATUS_UNSUCCESSFUL;
00871 }
00872
00873 if (sscanf(argv[3], "%ld", &offset) == 0) {
00874 printf("lock: error=-1 (error parsing fd)\n");
00875 return NT_STATUS_UNSUCCESSFUL;
00876 }
00877
00878 if (sscanf(argv[4], "%ld", &count) == 0) {
00879 printf("lock: error=-1 (error parsing fd)\n");
00880 return NT_STATUS_UNSUCCESSFUL;
00881 }
00882
00883 type = 0;
00884 typestr = argv[5];
00885 while(*typestr) {
00886 switch (*typestr) {
00887 case 'R':
00888 type |= F_RDLCK;
00889 break;
00890 case 'W':
00891 type |= F_WRLCK;
00892 break;
00893 case 'U':
00894 type |= F_UNLCK;
00895 break;
00896 default:
00897 printf("lock: error=-1 (invalid type flag!)\n");
00898 return NT_STATUS_UNSUCCESSFUL;
00899 }
00900 typestr++;
00901 }
00902
00903 printf("lock: debug lock(fd=%d, op=%d, offset=%ld, count=%ld, type=%d))\n", fd, op, offset, count, type);
00904
00905 if ((ret = SMB_VFS_LOCK(vfs->files[fd], fd, op, offset, count, type)) == False) {
00906 printf("lock: error=%d (%s)\n", errno, strerror(errno));
00907 return NT_STATUS_UNSUCCESSFUL;
00908 }
00909
00910 printf("lock: ok\n");
00911 return NT_STATUS_OK;
00912 }
00913
00914 static NTSTATUS cmd_symlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00915 {
00916 if (argc != 3) {
00917 printf("Usage: symlink <path> <link>\n");
00918 return NT_STATUS_OK;
00919 }
00920
00921 if (SMB_VFS_SYMLINK(vfs->conn, argv[1], argv[2]) == -1) {
00922 printf("symlink: error=%d (%s)\n", errno, strerror(errno));
00923 return NT_STATUS_UNSUCCESSFUL;
00924 }
00925
00926 printf("symlink: ok\n");
00927 return NT_STATUS_OK;
00928 }
00929
00930
00931 static NTSTATUS cmd_readlink(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00932 {
00933 char buffer[PATH_MAX];
00934 int size;
00935
00936 if (argc != 2) {
00937 printf("Usage: readlink <path>\n");
00938 return NT_STATUS_OK;
00939 }
00940
00941 if ((size = SMB_VFS_READLINK(vfs->conn, argv[1], buffer, PATH_MAX)) == -1) {
00942 printf("readlink: error=%d (%s)\n", errno, strerror(errno));
00943 return NT_STATUS_UNSUCCESSFUL;
00944 }
00945
00946 buffer[size] = '\0';
00947 printf("readlink: %s\n", buffer);
00948 return NT_STATUS_OK;
00949 }
00950
00951
00952 static NTSTATUS cmd_link(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00953 {
00954 if (argc != 3) {
00955 printf("Usage: link <path> <link>\n");
00956 return NT_STATUS_OK;
00957 }
00958
00959 if (SMB_VFS_LINK(vfs->conn, argv[1], argv[2]) == -1) {
00960 printf("link: error=%d (%s)\n", errno, strerror(errno));
00961 return NT_STATUS_UNSUCCESSFUL;
00962 }
00963
00964 printf("link: ok\n");
00965 return NT_STATUS_OK;
00966 }
00967
00968 static NTSTATUS cmd_mknod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
00969 {
00970 mode_t mode;
00971 unsigned int dev_val;
00972 SMB_DEV_T dev;
00973
00974 if (argc != 4) {
00975 printf("Usage: mknod <path> <mode> <dev>\n");
00976 printf(" mode is octal\n");
00977 printf(" dev is hex\n");
00978 return NT_STATUS_OK;
00979 }
00980
00981 if (sscanf(argv[2], "%o", &mode) == 0) {
00982 printf("open: error=-1 (invalid mode!)\n");
00983 return NT_STATUS_UNSUCCESSFUL;
00984 }
00985
00986 if (sscanf(argv[3], "%x", &dev_val) == 0) {
00987 printf("open: error=-1 (invalid dev!)\n");
00988 return NT_STATUS_UNSUCCESSFUL;
00989 }
00990 dev = (SMB_DEV_T)dev_val;
00991
00992 if (SMB_VFS_MKNOD(vfs->conn, argv[1], mode, dev) == -1) {
00993 printf("mknod: error=%d (%s)\n", errno, strerror(errno));
00994 return NT_STATUS_UNSUCCESSFUL;
00995 }
00996
00997 printf("mknod: ok\n");
00998 return NT_STATUS_OK;
00999 }
01000
01001 static NTSTATUS cmd_realpath(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
01002 {
01003 char respath[PATH_MAX];
01004
01005 if (argc != 2) {
01006 printf("Usage: realpath <path>\n");
01007 return NT_STATUS_OK;
01008 }
01009
01010 if (SMB_VFS_REALPATH(vfs->conn, argv[1], respath) == NULL) {
01011 printf("realpath: error=%d (%s)\n", errno, strerror(errno));
01012 return NT_STATUS_UNSUCCESSFUL;
01013 }
01014
01015 printf("realpath: ok\n");
01016 return NT_STATUS_OK;
01017 }
01018
01019 struct cmd_set vfs_commands[] = {
01020
01021 { "VFS Commands" },
01022
01023 { "load", cmd_load_module, "Load a module", "load <module.so>" },
01024 { "populate", cmd_populate, "Populate a data buffer", "populate <char> <size>" },
01025 { "showdata", cmd_show_data, "Show data currently in data buffer", "show_data [<offset> <len>]"},
01026 { "connect", cmd_connect, "VFS connect()", "connect" },
01027 { "disconnect", cmd_disconnect, "VFS disconnect()", "disconnect" },
01028 { "disk_free", cmd_disk_free, "VFS disk_free()", "disk_free <path>" },
01029 { "opendir", cmd_opendir, "VFS opendir()", "opendir <fname>" },
01030 { "readdir", cmd_readdir, "VFS readdir()", "readdir" },
01031 { "mkdir", cmd_mkdir, "VFS mkdir()", "mkdir <path>" },
01032 { "rmdir", cmd_pathfunc, "VFS rmdir()", "rmdir <path>" },
01033 { "closedir", cmd_closedir, "VFS closedir()", "closedir" },
01034 { "open", cmd_open, "VFS open()", "open <fname>" },
01035 { "close", cmd_close, "VFS close()", "close <fd>" },
01036 { "read", cmd_read, "VFS read()", "read <fd> <size>" },
01037 { "write", cmd_write, "VFS write()", "write <fd> <size>" },
01038 { "lseek", cmd_lseek, "VFS lseek()", "lseek <fd> <offset> <whence>" },
01039 { "rename", cmd_rename, "VFS rename()", "rename <old> <new>" },
01040 { "fsync", cmd_fsync, "VFS fsync()", "fsync <fd>" },
01041 { "stat", cmd_stat, "VFS stat()", "stat <fname>" },
01042 { "fstat", cmd_fstat, "VFS fstat()", "fstat <fd>" },
01043 { "lstat", cmd_lstat, "VFS lstat()", "lstat <fname>" },
01044 { "unlink", cmd_pathfunc, "VFS unlink()", "unlink <fname>" },
01045 { "chmod", cmd_chmod, "VFS chmod()", "chmod <path> <mode>" },
01046 { "fchmod", cmd_fchmod, "VFS fchmod()", "fchmod <fd> <mode>" },
01047 { "chown", cmd_chown, "VFS chown()", "chown <path> <uid> <gid>" },
01048 { "fchown", cmd_fchown, "VFS fchown()", "fchown <fd> <uid> <gid>" },
01049 { "chdir", cmd_pathfunc, "VFS chdir()", "chdir <path>" },
01050 { "getwd", cmd_getwd, "VFS getwd()", "getwd" },
01051 { "utime", cmd_utime, "VFS utime()", "utime <path> <access> <modify>" },
01052 { "ftruncate", cmd_ftruncate, "VFS ftruncate()", "ftruncate <fd> <length>" },
01053 { "lock", cmd_lock, "VFS lock()", "lock <f> <op> <offset> <count> <type>" },
01054 { "symlink", cmd_symlink, "VFS symlink()", "symlink <old> <new>" },
01055 { "readlink", cmd_readlink, "VFS readlink()", "readlink <path>" },
01056 { "link", cmd_link, "VFS link()", "link <oldpath> <newpath>" },
01057 { "mknod", cmd_mknod, "VFS mknod()", "mknod <path> <mode> <dev>" },
01058 { "realpath", cmd_realpath, "VFS realpath()", "realpath <path>" },
01059 { NULL }
01060 };