torture/cmd_vfs.c

ソースコードを見る。

関数

static NTSTATUS cmd_load_module (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_populate (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_show_data (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_connect (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_disconnect (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_disk_free (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_opendir (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_readdir (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_mkdir (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_closedir (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_open (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_pathfunc (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_close (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_read (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_write (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_lseek (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_rename (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_fsync (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_stat (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_fstat (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_lstat (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_chmod (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_fchmod (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_chown (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_fchown (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_getwd (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_utime (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_ftruncate (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_lock (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_symlink (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_readlink (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_link (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_mknod (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
static NTSTATUS cmd_realpath (struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)

変数

static const char * null_string = ""
cmd_set vfs_commands []


関数

static NTSTATUS cmd_load_module ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c28 行で定義されています。

参照先 vfs_state::connprintf()vfs_init_custom().

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 }

static NTSTATUS cmd_populate ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c47 行で定義されています。

参照先 cvfs_state::datavfs_state::data_sizeprintf()size.

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 }

static NTSTATUS cmd_show_data ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c67 行で定義されています。

参照先 vfs_state::datavfs_state::data_sizedump_data()lenprintf().

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 }

static NTSTATUS cmd_connect ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c95 行で定義されています。

参照先 vfs_state::conn.

00096 {
00097         SMB_VFS_CONNECT(vfs->conn, lp_servicename(SNUM(vfs->conn)), "vfstest");
00098         return NT_STATUS_OK;
00099 }

static NTSTATUS cmd_disconnect ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c101 行で定義されています。

参照先 vfs_state::conn.

00102 {
00103         SMB_VFS_DISCONNECT(vfs->conn);
00104         return NT_STATUS_OK;
00105 }

static NTSTATUS cmd_disk_free ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c107 行で定義されています。

参照先 vfs_state::connprintf().

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 }

static NTSTATUS cmd_opendir ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c125 行で定義されています。

参照先 vfs_state::connvfs_state::currentdirerrnoprintf()strerror().

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 }

static NTSTATUS cmd_readdir ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c143 行で定義されています。

参照先 vfs_state::connvfs_state::currentdirprintf().

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 }

static NTSTATUS cmd_mkdir ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c163 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_closedir ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c180 行で定義されています。

参照先 vfs_state::connvfs_state::currentdirerrnoprintf()strerror().

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 }

static NTSTATUS cmd_open ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c201 行で定義されています。

参照先 vfs_state::connfiles_struct::connerrnofd_handle::fdfiles_struct::fhvfs_state::filesflagsfiles_struct::fsp_namemodeprintf()strerror().

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 }

static NTSTATUS cmd_pathfunc ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c301 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_close ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c331 行で定義されています。

参照先 errnofdfiles_struct::fhvfs_state::filesfiles_struct::fsp_nameprintf()strerror().

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 }

static NTSTATUS cmd_read ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c360 行で定義されています。

参照先 vfs_state::datavfs_state::data_sizeerrnofdvfs_state::filesprintf()sizestrerror().

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         /* do some error checking on these */
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 }

static NTSTATUS cmd_write ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c391 行で定義されています。

参照先 vfs_state::datavfs_state::data_sizeerrnofdvfs_state::filesprintf()sizestrerror().

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         /* some error checking should go here */
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 }

static NTSTATUS cmd_lseek ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c425 行で定義されています。

参照先 errnofdvfs_state::filesprintf()strerror().

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 }

static NTSTATUS cmd_rename ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c455 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_fsync ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c474 行で定義されています。

参照先 errnofdvfs_state::filesprintf()strerror().

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 }

static NTSTATUS cmd_stat ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c494 行で定義されています。

参照先 vfs_state::connerrnonull_stringprintf()strerror()sys_getgrgid()sys_getpwuid().

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 }

static NTSTATUS cmd_fstat ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c551 行で定義されています。

参照先 errnofdvfs_state::filesnull_stringprintf()strerror()sys_getgrgid()sys_getpwuid().

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 }

static NTSTATUS cmd_lstat ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c617 行で定義されています。

参照先 vfs_state::connerrnonull_stringprintf()strerror()sys_getgrgid()sys_getpwuid().

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 }

static NTSTATUS cmd_chmod ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c671 行で定義されています。

参照先 vfs_state::connerrnomodeprintf()strerror().

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 }

static NTSTATUS cmd_fchmod ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c690 行で定義されています。

参照先 errnofdvfs_state::filesmodeprintf()strerror().

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 }

static NTSTATUS cmd_chown ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c720 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_fchown ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c741 行で定義されています。

参照先 errnofdvfs_state::filesprintf()strerror().

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 }

static NTSTATUS cmd_getwd ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c772 行で定義されています。

参照先 bufvfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_utime ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c784 行で定義されています。

参照先 vfs_state::connconvert_time_t_to_timespec()errnoprintf()strerror().

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 }

static NTSTATUS cmd_ftruncate ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c802 行で定義されています。

参照先 errnofdvfs_state::filesprintf()strerror().

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 }

static NTSTATUS cmd_lock ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c831 行で定義されています。

参照先 errnofdvfs_state::filesprintf()strerror()type.

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 }

static NTSTATUS cmd_symlink ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c914 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_readlink ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c931 行で定義されています。

参照先 vfs_state::connerrnoprintf()sizestrerror().

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 }

static NTSTATUS cmd_link ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c952 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }

static NTSTATUS cmd_mknod ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c968 行で定義されています。

参照先 vfs_state::conndeverrnomodeprintf()strerror().

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 }

static NTSTATUS cmd_realpath ( struct vfs_state vfs,
TALLOC_CTX mem_ctx,
int  argc,
const char **  argv 
) [static]

cmd_vfs.c1001 行で定義されています。

参照先 vfs_state::connerrnoprintf()strerror().

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 }


変数

const char* null_string = "" [static]

cmd_vfs.c26 行で定義されています。

struct cmd_set vfs_commands[]

cmd_vfs.c1019 行で定義されています。


Sambaに対してSat Aug 29 21:24:31 2009に生成されました。  doxygen 1.4.7