jim-file.c

   1 /*
   2  * Implements the file command for jim
   3  *
   4  * (c) 2008 Steve Bennett <steveb@workware.net.au>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above
  13  *    copyright notice, this list of conditions and the following
  14  *    disclaimer in the documentation and/or other materials
  15  *    provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  21  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  28  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and documentation
  31  * are those of the authors and should not be interpreted as representing
  32  * official policies, either expressed or implied, of the Jim Tcl Project.
  33  *
  34  * Based on code originally from Tcl 6.7:
  35  *
  36  * Copyright 1987-1991 Regents of the University of California
  37  * Permission to use, copy, modify, and distribute this
  38  * software and its documentation for any purpose and without
  39  * fee is hereby granted, provided that the above copyright
  40  * notice appear in all copies.  The University of California
  41  * makes no representations about the suitability of this
  42  * software for any purpose.  It is provided "as is" without
  43  * express or implied warranty.
  44  */
  45
  46 #include <limits.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <stdio.h>
  50 #include <errno.h>
  51 #include <sys/stat.h>
  52
  53 #include "jim.h"
  54 #include "jimautoconf.h"
  55 #include "jim-subcmd.h"
  56
  57 #ifdef HAVE_UTIMES
  58 #include <sys/time.h>
  59 #endif
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #elif defined(_MSC_VER)
  63 #include <direct.h>
  64 #define F_OK 0
  65 #define W_OK 2
  66 #define R_OK 4
  67 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
  68 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  69 #endif
  70
  71 # ifndef MAXPATHLEN
  72 # define MAXPATHLEN JIM_PATH_LEN
  73 # endif
  74
  75 /*
  76  *----------------------------------------------------------------------
  77  *
  78  * JimGetFileType --
  79  *
  80  *  Given a mode word, returns a string identifying the type of a
  81  *  file.
  82  *
  83  * Results:
  84  *  A static text string giving the file type from mode.
  85  *
  86  * Side effects:
  87  *  None.
  88  *
  89  *----------------------------------------------------------------------
  90  */
  91
  92 static const char *JimGetFileType(int mode)
  93 {
  94     if (S_ISREG(mode)) {
  95         return "file";
  96     }
  97     else if (S_ISDIR(mode)) {
  98         return "directory";
  99     }
 100 #ifdef S_ISCHR
 101     else if (S_ISCHR(mode)) {
 102         return "characterSpecial";
 103     }
 104 #endif
 105 #ifdef S_ISBLK
 106     else if (S_ISBLK(mode)) {
 107         return "blockSpecial";
 108     }
 109 #endif
 110 #ifdef S_ISFIFO
 111     else if (S_ISFIFO(mode)) {
 112         return "fifo";
 113     }
 114 #endif
 115 #ifdef S_ISLNK
 116     else if (S_ISLNK(mode)) {
 117         return "link";
 118     }
 119 #endif
 120 #ifdef S_ISSOCK
 121     else if (S_ISSOCK(mode)) {
 122         return "socket";
 123     }
 124 #endif
 125     return "unknown";
 126 }
 127
 128 /*
 129  *----------------------------------------------------------------------
 130  *
 131  * StoreStatData --
 132  *
 133  *  This is a utility procedure that breaks out the fields of a
 134  *  "stat" structure and stores them in textual form into the
 135  *  elements of an associative array.
 136  *
 137  * Results:
 138  *  Returns a standard Tcl return value.  If an error occurs then
 139  *  a message is left in interp->result.
 140  *
 141  * Side effects:
 142  *  Elements of the associative array given by "varName" are modified.
 143  *
 144  *----------------------------------------------------------------------
 145  */
 146
 147 static int set_array_int_value(Jim_Interp *interp, Jim_Obj *container, const char *key,
 148     jim_wide value)
 149 {
 150     Jim_Obj *nameobj = Jim_NewStringObj(interp, key, -1);
 151     Jim_Obj *valobj = Jim_NewWideObj(interp, value);
 152
 153     if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj, JIM_ERRMSG) != JIM_OK) {
 154         Jim_FreeObj(interp, nameobj);
 155         Jim_FreeObj(interp, valobj);
 156         return JIM_ERR;
 157     }
 158     return JIM_OK;
 159 }
 160
 161 static int set_array_string_value(Jim_Interp *interp, Jim_Obj *container, const char *key,
 162     const char *value)
 163 {
 164     Jim_Obj *nameobj = Jim_NewStringObj(interp, key, -1);
 165     Jim_Obj *valobj = Jim_NewStringObj(interp, value, -1);
 166
 167     if (Jim_SetDictKeysVector(interp, container, &nameobj, 1, valobj, JIM_ERRMSG) != JIM_OK) {
 168         Jim_FreeObj(interp, nameobj);
 169         Jim_FreeObj(interp, valobj);
 170         return JIM_ERR;
 171     }
 172     return JIM_OK;
 173 }
 174
 175 static int StoreStatData(Jim_Interp *interp, Jim_Obj *varName, const struct stat *sb)
 176 {
 177     if (set_array_int_value(interp, varName, "dev", sb->st_dev) != JIM_OK) {
 178         Jim_SetResultFormatted(interp, "can't set \"%#s(dev)\": variable isn't array", varName);
 179         return JIM_ERR;
 180     }
 181     set_array_int_value(interp, varName, "ino", sb->st_ino);
 182     set_array_int_value(interp, varName, "mode", sb->st_mode);
 183     set_array_int_value(interp, varName, "nlink", sb->st_nlink);
 184     set_array_int_value(interp, varName, "uid", sb->st_uid);
 185     set_array_int_value(interp, varName, "gid", sb->st_gid);
 186     set_array_int_value(interp, varName, "size", sb->st_size);
 187     set_array_int_value(interp, varName, "atime", sb->st_atime);
 188     set_array_int_value(interp, varName, "mtime", sb->st_mtime);
 189     set_array_int_value(interp, varName, "ctime", sb->st_ctime);
 190     set_array_string_value(interp, varName, "type", JimGetFileType((int)sb->st_mode));
 191
 192     /* And also return the value */
 193     Jim_SetResult(interp, Jim_GetVariable(interp, varName, 0));
 194
 195     return JIM_OK;
 196 }
 197
 198 static int file_cmd_dirname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 199 {
 200     const char *path = Jim_String(argv[0]);
 201     const char *p = strrchr(path, '/');
 202
 203     if (!p) {
 204         Jim_SetResultString(interp, ".", -1);
 205     }
 206     else if (p == path) {
 207         Jim_SetResultString(interp, "/", -1);
 208     }
 209 #if defined(__MINGW32__) || defined(_MSC_VER)
 210     else if (p[-1] == ':') {
 211         /* z:/dir => z:/ */
 212         Jim_SetResultString(interp, path, p - path + 1);
 213     }
 214 #endif
 215     else {
 216         Jim_SetResultString(interp, path, p - path);
 217     }
 218     return JIM_OK;
 219 }
 220
 221 static int file_cmd_rootname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 222 {
 223     const char *path = Jim_String(argv[0]);
 224     const char *lastSlash = strrchr(path, '/');
 225     const char *p = strrchr(path, '.');
 226
 227     if (p == NULL || (lastSlash != NULL && lastSlash > p)) {
 228         Jim_SetResult(interp, argv[0]);
 229     }
 230     else {
 231         Jim_SetResultString(interp, path, p - path);
 232     }
 233     return JIM_OK;
 234 }
 235
 236 static int file_cmd_extension(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 237 {
 238     const char *path = Jim_String(argv[0]);
 239     const char *lastSlash = strrchr(path, '/');
 240     const char *p = strrchr(path, '.');
 241
 242     if (p == NULL || (lastSlash != NULL && lastSlash >= p)) {
 243         p = "";
 244     }
 245     Jim_SetResultString(interp, p, -1);
 246     return JIM_OK;
 247 }
 248
 249 static int file_cmd_tail(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 250 {
 251     const char *path = Jim_String(argv[0]);
 252     const char *lastSlash = strrchr(path, '/');
 253
 254     if (lastSlash) {
 255         Jim_SetResultString(interp, lastSlash + 1, -1);
 256     }
 257     else {
 258         Jim_SetResult(interp, argv[0]);
 259     }
 260     return JIM_OK;
 261 }
 262
 263 static int file_cmd_normalize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 264 {
 265 #ifdef HAVE_REALPATH
 266     const char *path = Jim_String(argv[0]);
 267     char *newname = Jim_Alloc(MAXPATHLEN + 1);
 268
 269     if (realpath(path, newname)) {
 270         Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, -1));
 271     }
 272     else {
 273         Jim_Free(newname);
 274         Jim_SetResult(interp, argv[0]);
 275     }
 276     return JIM_OK;
 277 #else
 278     Jim_SetResultString(interp, "Not implemented", -1);
 279     return JIM_ERR;
 280 #endif
 281 }
 282
 283 static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 284 {
 285     int i;
 286     char *newname = Jim_Alloc(MAXPATHLEN + 1);
 287     char *last = newname;
 288
 289     *newname = 0;
 290
 291     /* Simple implementation for now */
 292     for (i = 0; i < argc; i++) {
 293         int len;
 294         const char *part = Jim_GetString(argv[i], &len);
 295
 296         if (*part == '/') {
 297             /* Absolute component, so go back to the start */
 298             last = newname;
 299         }
 300 #if defined(__MINGW32__) || defined(_MSC_VER)
 301         else if (strchr(part, ':')) {
 302             /* Absolute compontent on mingw, so go back to the start */
 303             last = newname;
 304         }
 305 #endif
 306         else if (part[0] == '.') {
 307             if (part[1] == '/') {
 308                 part += 2;
 309                 len -= 2;
 310             }
 311             else if (part[1] == 0 && last != newname) {
 312                 /* Adding '.' to an existing path does nothing */
 313                 continue;
 314             }
 315         }
 316
 317         /* Add a slash if needed */
 318         if (last != newname && last[-1] != '/') {
 319             *last++ = '/';
 320         }
 321
 322         if (len) {
 323             if (last + len - newname >= MAXPATHLEN) {
 324                 Jim_Free(newname);
 325                 Jim_SetResultString(interp, "Path too long", -1);
 326                 return JIM_ERR;
 327             }
 328             memcpy(last, part, len);
 329             last += len;
 330         }
 331
 332         /* Remove a slash if needed */
 333         if (last > newname + 1 && last[-1] == '/') {
 334             *--last = 0;
 335         }
 336     }
 337
 338     *last = 0;
 339
 340     /* Probably need to handle some special cases ... */
 341
 342     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, last - newname));
 343
 344     return JIM_OK;
 345 }
 346
 347 static int file_access(Jim_Interp *interp, Jim_Obj *filename, int mode)
 348 {
 349     const char *path = Jim_String(filename);
 350     int rc = access(path, mode);
 351
 352     Jim_SetResultBool(interp, rc != -1);
 353
 354     return JIM_OK;
 355 }
 356
 357 static int file_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 358 {
 359     return file_access(interp, argv[0], R_OK);
 360 }
 361
 362 static int file_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 363 {
 364     return file_access(interp, argv[0], W_OK);
 365 }
 366
 367 static int file_cmd_executable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 368 {
 369 #ifdef X_OK
 370     return file_access(interp, argv[0], X_OK);
 371 #else
 372     /* XXX: X_OK doesn't work under Windows.
 373      * In any case, may need to add .exe, etc. so just lie!
 374      */
 375     Jim_SetResultBool(interp, 1);
 376     return JIM_OK;
 377 #endif
 378 }
 379
 380 static int file_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 381 {
 382     return file_access(interp, argv[0], F_OK);
 383 }
 384
 385 static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 386 {
 387     int force = Jim_CompareStringImmediate(interp, argv[0], "-force");
 388
 389     if (force || Jim_CompareStringImmediate(interp, argv[0], "--")) {
 390         argc++;
 391         argv--;
 392     }
 393
 394     while (argc--) {
 395         const char *path = Jim_String(argv[0]);
 396
 397         if (unlink(path) == -1 && errno != ENOENT) {
 398             if (rmdir(path) == -1) {
 399                 /* Maybe try using the script helper */
 400                 if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
 401                     Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path,
 402                         strerror(errno));
 403                     return JIM_ERR;
 404                 }
 405             }
 406         }
 407         argv++;
 408     }
 409     return JIM_OK;
 410 }
 411
 412 #ifdef HAVE_MKDIR_ONE_ARG
 413 #define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME)
 414 #else
 415 #define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME, 0755)
 416 #endif
 417
 418 /**
 419  * Create directory, creating all intermediate paths if necessary.
 420  *
 421  * Returns 0 if OK or -1 on failure (and sets errno)
 422  *
 423  * Note: The path may be modified.
 424  */
 425 static int mkdir_all(char *path)
 426 {
 427     int ok = 1;
 428
 429     /* First time just try to make the dir */
 430     goto first;
 431
 432     while (ok--) {
 433         /* Must have failed the first time, so recursively make the parent and try again */
 434         char *slash = strrchr(path, '/');
 435
 436         if (slash && slash != path) {
 437             *slash = 0;
 438             if (mkdir_all(path) != 0) {
 439                 return -1;
 440             }
 441             *slash = '/';
 442         }
 443       first:
 444         if (MKDIR_DEFAULT(path) == 0) {
 445             return 0;
 446         }
 447         if (errno == ENOENT) {
 448             /* Create the parent and try again */
 449             continue;
 450         }
 451         /* Maybe it already exists as a directory */
 452         if (errno == EEXIST) {
 453             struct stat sb;
 454
 455             if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
 456                 return 0;
 457             }
 458             /* Restore errno */
 459             errno = EEXIST;
 460         }
 461         /* Failed */
 462         break;
 463     }
 464     return -1;
 465 }
 466
 467 static int file_cmd_mkdir(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 468 {
 469     while (argc--) {
 470         char *path = Jim_StrDup(Jim_String(argv[0]));
 471         int rc = mkdir_all(path);
 472
 473         Jim_Free(path);
 474         if (rc != 0) {
 475             Jim_SetResultFormatted(interp, "can't create directory \"%#s\": %s", argv[0],
 476                 strerror(errno));
 477             return JIM_ERR;
 478         }
 479         argv++;
 480     }
 481     return JIM_OK;
 482 }
 483
 484 #ifdef HAVE_MKSTEMP
 485 static int file_cmd_tempfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 486 {
 487     int fd;
 488     char *filename;
 489     const char *template = "/tmp/tcl.tmp.XXXXXX";
 490
 491     if (argc >= 1) {
 492         template = Jim_String(argv[0]);
 493     }
 494     filename = Jim_StrDup(template);
 495
 496     fd = mkstemp(filename);
 497     if (fd < 0) {
 498         Jim_SetResultString(interp, "Failed to create tempfile", -1);
 499         return JIM_ERR;
 500     }
 501     close(fd);
 502
 503     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, filename, -1));
 504     return JIM_OK;
 505 }
 506 #endif
 507
 508 static int file_cmd_rename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 509 {
 510     const char *source;
 511     const char *dest;
 512     int force = 0;
 513
 514     if (argc == 3) {
 515         if (!Jim_CompareStringImmediate(interp, argv[0], "-force")) {
 516             return -1;
 517         }
 518         force++;
 519         argv++;
 520         argc--;
 521     }
 522
 523     source = Jim_String(argv[0]);
 524     dest = Jim_String(argv[1]);
 525
 526     if (!force && access(dest, F_OK) == 0) {
 527         Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": target exists", argv[0],
 528             argv[1]);
 529         return JIM_ERR;
 530     }
 531
 532     if (rename(source, dest) != 0) {
 533         Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": %s", argv[0], argv[1],
 534             strerror(errno));
 535         return JIM_ERR;
 536     }
 537
 538     return JIM_OK;
 539 }
 540
 541 static int file_stat(Jim_Interp *interp, Jim_Obj *filename, struct stat *sb)
 542 {
 543     const char *path = Jim_String(filename);
 544
 545     if (stat(path, sb) == -1) {
 546         Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
 547         return JIM_ERR;
 548     }
 549     return JIM_OK;
 550 }
 551
 552 #ifndef HAVE_LSTAT
 553 #define lstat stat
 554 #endif
 555
 556 static int file_lstat(Jim_Interp *interp, Jim_Obj *filename, struct stat *sb)
 557 {
 558     const char *path = Jim_String(filename);
 559
 560     if (lstat(path, sb) == -1) {
 561         Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
 562         return JIM_ERR;
 563     }
 564     return JIM_OK;
 565 }
 566
 567 static int file_cmd_atime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 568 {
 569     struct stat sb;
 570
 571     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 572         return JIM_ERR;
 573     }
 574     Jim_SetResultInt(interp, sb.st_atime);
 575     return JIM_OK;
 576 }
 577
 578 static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 579 {
 580     struct stat sb;
 581
 582     if (argc == 2) {
 583 #ifdef HAVE_UTIMES
 584         jim_wide newtime;
 585         struct timeval times[2];
 586
 587         if (Jim_GetWide(interp, argv[1], &newtime) != JIM_OK) {
 588             return JIM_ERR;
 589         }
 590
 591         times[1].tv_sec = times[0].tv_sec = newtime;
 592         times[1].tv_usec = times[0].tv_usec = 0;
 593
 594         if (utimes(Jim_String(argv[0]), times) != 0) {
 595             Jim_SetResultFormatted(interp, "can't set time on \"%#s\": %s", argv[0], strerror(errno));
 596             return JIM_ERR;
 597         }
 598 #else
 599         Jim_SetResultString(interp, "Not implemented", -1);
 600         return JIM_ERR;
 601 #endif
 602     }
 603     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 604         return JIM_ERR;
 605     }
 606     Jim_SetResultInt(interp, sb.st_mtime);
 607     return JIM_OK;
 608 }
 609
 610 static int file_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 611 {
 612     return Jim_EvalPrefix(interp, "file copy", argc, argv);
 613 }
 614
 615 static int file_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 616 {
 617     struct stat sb;
 618
 619     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 620         return JIM_ERR;
 621     }
 622     Jim_SetResultInt(interp, sb.st_size);
 623     return JIM_OK;
 624 }
 625
 626 static int file_cmd_isdirectory(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 627 {
 628     struct stat sb;
 629     int ret = 0;
 630
 631     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 632         ret = S_ISDIR(sb.st_mode);
 633     }
 634     Jim_SetResultInt(interp, ret);
 635     return JIM_OK;
 636 }
 637
 638 static int file_cmd_isfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 639 {
 640     struct stat sb;
 641     int ret = 0;
 642
 643     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 644         ret = S_ISREG(sb.st_mode);
 645     }
 646     Jim_SetResultInt(interp, ret);
 647     return JIM_OK;
 648 }
 649
 650 #ifdef HAVE_GETEUID
 651 static int file_cmd_owned(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 652 {
 653     struct stat sb;
 654     int ret = 0;
 655
 656     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 657         ret = (geteuid() == sb.st_uid);
 658     }
 659     Jim_SetResultInt(interp, ret);
 660     return JIM_OK;
 661 }
 662 #endif
 663
 664 #if defined(HAVE_READLINK)
 665 static int file_cmd_readlink(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 666 {
 667     const char *path = Jim_String(argv[0]);
 668     char *linkValue = Jim_Alloc(MAXPATHLEN + 1);
 669
 670     int linkLength = readlink(path, linkValue, MAXPATHLEN);
 671
 672     if (linkLength == -1) {
 673         Jim_Free(linkValue);
 674         Jim_SetResultFormatted(interp, "couldn't readlink \"%#s\": %s", argv[0], strerror(errno));
 675         return JIM_ERR;
 676     }
 677     linkValue[linkLength] = 0;
 678     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, linkValue, linkLength));
 679     return JIM_OK;
 680 }
 681 #endif
 682
 683 static int file_cmd_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 684 {
 685     struct stat sb;
 686
 687     if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
 688         return JIM_ERR;
 689     }
 690     Jim_SetResultString(interp, JimGetFileType((int)sb.st_mode), -1);
 691     return JIM_OK;
 692 }
 693
 694 static int file_cmd_lstat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 695 {
 696     struct stat sb;
 697
 698     if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
 699         return JIM_ERR;
 700     }
 701     return StoreStatData(interp, argv[1], &sb);
 702 }
 703
 704 static int file_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 705 {
 706     struct stat sb;
 707
 708     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 709         return JIM_ERR;
 710     }
 711     return StoreStatData(interp, argv[1], &sb);
 712 }
 713
 714 static const jim_subcmd_type file_command_table[] = {
 715     {   "atime",
 716         "name",
 717         file_cmd_atime,
 718         1,
 719         1,
 720         /* Description: Last access time */
 721     },
 722     {   "mtime",
 723         "name ?time?",
 724         file_cmd_mtime,
 725         1,
 726         2,
 727         /* Description: Get or set last modification time */
 728     },
 729     {   "copy",
 730         "?-force? source dest",
 731         file_cmd_copy,
 732         2,
 733         3,
 734         /* Description: Copy source file to destination file */
 735     },
 736     {   "dirname",
 737         "name",
 738         file_cmd_dirname,
 739         1,
 740         1,
 741         /* Description: Directory part of the name */
 742     },
 743     {   "rootname",
 744         "name",
 745         file_cmd_rootname,
 746         1,
 747         1,
 748         /* Description: Name without any extension */
 749     },
 750     {   "extension",
 751         "name",
 752         file_cmd_extension,
 753         1,
 754         1,
 755         /* Description: Last extension including the dot */
 756     },
 757     {   "tail",
 758         "name",
 759         file_cmd_tail,
 760         1,
 761         1,
 762         /* Description: Last component of the name */
 763     },
 764     {   "normalize",
 765         "name",
 766         file_cmd_normalize,
 767         1,
 768         1,
 769         /* Description: Normalized path of name */
 770     },
 771     {   "join",
 772         "name ?name ...?",
 773         file_cmd_join,
 774         1,
 775         -1,
 776         /* Description: Join multiple path components */
 777     },
 778     {   "readable",
 779         "name",
 780         file_cmd_readable,
 781         1,
 782         1,
 783         /* Description: Is file readable */
 784     },
 785     {   "writable",
 786         "name",
 787         file_cmd_writable,
 788         1,
 789         1,
 790         /* Description: Is file writable */
 791     },
 792     {   "executable",
 793         "name",
 794         file_cmd_executable,
 795         1,
 796         1,
 797         /* Description: Is file executable */
 798     },
 799     {   "exists",
 800         "name",
 801         file_cmd_exists,
 802         1,
 803         1,
 804         /* Description: Does file exist */
 805     },
 806     {   "delete",
 807         "?-force|--? name ...",
 808         file_cmd_delete,
 809         1,
 810         -1,
 811         /* Description: Deletes the files or directories (must be empty unless -force) */
 812     },
 813     {   "mkdir",
 814         "dir ...",
 815         file_cmd_mkdir,
 816         1,
 817         -1,
 818         /* Description: Creates the directories */
 819     },
 820 #ifdef HAVE_MKSTEMP
 821     {   "tempfile",
 822         "?template?",
 823         file_cmd_tempfile,
 824         0,
 825         1,
 826         /* Description: Creates a temporary filename */
 827     },
 828 #endif
 829     {   "rename",
 830         "?-force? source dest",
 831         file_cmd_rename,
 832         2,
 833         3,
 834         /* Description: Renames a file */
 835     },
 836 #if defined(HAVE_READLINK)
 837     {   "readlink",
 838         "name",
 839         file_cmd_readlink,
 840         1,
 841         1,
 842         /* Description: Value of the symbolic link */
 843     },
 844 #endif
 845     {   "size",
 846         "name",
 847         file_cmd_size,
 848         1,
 849         1,
 850         /* Description: Size of file */
 851     },
 852     {   "stat",
 853         "name var",
 854         file_cmd_stat,
 855         2,
 856         2,
 857         /* Description: Stores results of stat in var array */
 858     },
 859     {   "lstat",
 860         "name var",
 861         file_cmd_lstat,
 862         2,
 863         2,
 864         /* Description: Stores results of lstat in var array */
 865     },
 866     {   "type",
 867         "name",
 868         file_cmd_type,
 869         1,
 870         1,
 871         /* Description: Returns type of the file */
 872     },
 873 #ifdef HAVE_GETEUID
 874     {   "owned",
 875         "name",
 876         file_cmd_owned,
 877         1,
 878         1,
 879         /* Description: Returns 1 if owned by the current owner */
 880     },
 881 #endif
 882     {   "isdirectory",
 883         "name",
 884         file_cmd_isdirectory,
 885         1,
 886         1,
 887         /* Description: Returns 1 if name is a directory */
 888     },
 889     {   "isfile",
 890         "name",
 891         file_cmd_isfile,
 892         1,
 893         1,
 894         /* Description: Returns 1 if name is a file */
 895     },
 896     {
 897         NULL
 898     }
 899 };
 900
 901 static int Jim_CdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 902 {
 903     const char *path;
 904
 905     if (argc != 2) {
 906         Jim_WrongNumArgs(interp, 1, argv, "dirname");
 907         return JIM_ERR;
 908     }
 909
 910     path = Jim_String(argv[1]);
 911
 912     if (chdir(path) != 0) {
 913         Jim_SetResultFormatted(interp, "couldn't change working directory to \"%s\": %s", path,
 914             strerror(errno));
 915         return JIM_ERR;
 916     }
 917     return JIM_OK;
 918 }
 919
 920 static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 921 {
 922     const int cwd_len = 2048;
 923     char *cwd = malloc(cwd_len);
 924
 925     if (getcwd(cwd, cwd_len) == NULL) {
 926         Jim_SetResultString(interp, "Failed to get pwd", -1);
 927         return JIM_ERR;
 928     }
 929 #if defined(__MINGW32__) || defined(_MSC_VER)
 930     {
 931         /* Try to keep backlashes out of paths */
 932         char *p = cwd;
 933         while ((p = strchr(p, '\\')) != NULL) {
 934             *p++ = '/';
 935         }
 936     }
 937 #endif
 938
 939     Jim_SetResultString(interp, cwd, -1);
 940
 941     free(cwd);
 942     return JIM_OK;
 943 }
 944
 945 int Jim_fileInit(Jim_Interp *interp)
 946 {
 947     if (Jim_PackageProvide(interp, "file", "1.0", JIM_ERRMSG))
 948         return JIM_ERR;
 949
 950     Jim_CreateCommand(interp, "file", Jim_SubCmdProc, (void *)file_command_table, NULL);
 951     Jim_CreateCommand(interp, "pwd", Jim_PwdCmd, NULL, NULL);
 952     Jim_CreateCommand(interp, "cd", Jim_CdCmd, NULL, NULL);
 953     return JIM_OK;
 954 }