関数 | |
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] |
参照先 vfs_state::conn・printf()・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] |
参照先 c・vfs_state::data・vfs_state::data_size・printf()・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] |
参照先 vfs_state::data・vfs_state::data_size・dump_data()・len・printf().
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] |
参照先 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] |
static NTSTATUS cmd_disk_free | ( | struct vfs_state * | vfs, | |
TALLOC_CTX * | mem_ctx, | |||
int | argc, | |||
const char ** | argv | |||
) | [static] |
参照先 vfs_state::conn・printf().
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] |
参照先 vfs_state::conn・vfs_state::currentdir・errno・printf()・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] |
参照先 vfs_state::conn・vfs_state::currentdir・printf().
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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 vfs_state::conn・vfs_state::currentdir・errno・printf()・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] |
参照先 vfs_state::conn・files_struct::conn・errno・fd_handle::fd・files_struct::fh・vfs_state::files・flags・files_struct::fsp_name・mode・printf()・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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 errno・fd・files_struct::fh・vfs_state::files・files_struct::fsp_name・printf()・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] |
参照先 vfs_state::data・vfs_state::data_size・errno・fd・vfs_state::files・printf()・size・strerror().
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] |
参照先 vfs_state::data・vfs_state::data_size・errno・fd・vfs_state::files・printf()・size・strerror().
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] |
参照先 errno・fd・vfs_state::files・printf()・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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 errno・fd・vfs_state::files・printf()・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] |
参照先 vfs_state::conn・errno・null_string・printf()・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] |
参照先 errno・fd・vfs_state::files・null_string・printf()・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] |
参照先 vfs_state::conn・errno・null_string・printf()・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] |
参照先 vfs_state::conn・errno・mode・printf()・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] |
参照先 errno・fd・vfs_state::files・mode・printf()・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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 errno・fd・vfs_state::files・printf()・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] |
参照先 buf・vfs_state::conn・errno・printf()・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] |
参照先 vfs_state::conn・convert_time_t_to_timespec()・errno・printf()・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] |
参照先 errno・fd・vfs_state::files・printf()・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] |
参照先 errno・fd・vfs_state::files・printf()・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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 vfs_state::conn・errno・printf()・size・strerror().
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] |
参照先 vfs_state::conn・errno・printf()・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] |
参照先 vfs_state::conn・dev・errno・mode・printf()・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] |
参照先 vfs_state::conn・errno・printf()・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] |
struct cmd_set vfs_commands[] |