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 <jimautoconf.h>
  54 #include <jim-subcmd.h>
  55
  56 #ifdef HAVE_UTIMES
  57 #include <sys/time.h>
  58 #endif
  59 #ifdef HAVE_UNISTD_H
  60 #include <unistd.h>
  61 #elif defined(_MSC_VER)
  62 #include <direct.h>
  63 #define F_OK 0
  64 #define W_OK 2
  65 #define R_OK 4
  66 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
  67 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
  68 #endif
  69
  70 # ifndef MAXPATHLEN
  71 # define MAXPATHLEN JIM_PATH_LEN
  72 # endif
  73
  74 #if defined(__MINGW32__) || defined(__MSYS__) || defined(_MSC_VER)
  75 #define ISWINDOWS 1
  76 #else
  77 #define ISWINDOWS 0
  78 #endif
  79
  80 /* extract nanosecond resolution mtime from struct stat */
  81 #if defined(HAVE_STRUCT_STAT_ST_MTIMESPEC)
  82     #define STAT_MTIME_US(STAT) ((STAT).st_mtimespec.tv_sec * 1000000ll + (STAT).st_mtimespec.tv_nsec / 1000)
  83 #elif defined(HAVE_STRUCT_STAT_ST_MTIM)
  84     #define STAT_MTIME_US(STAT) ((STAT).st_mtim.tv_sec * 1000000ll + (STAT).st_mtim.tv_nsec / 1000)
  85 #endif
  86
  87 /*
  88  *----------------------------------------------------------------------
  89  *
  90  * JimGetFileType --
  91  *
  92  *  Given a mode word, returns a string identifying the type of a
  93  *  file.
  94  *
  95  * Results:
  96  *  A static text string giving the file type from mode.
  97  *
  98  * Side effects:
  99  *  None.
 100  *
 101  *----------------------------------------------------------------------
 102  */
 103
 104 static const char *JimGetFileType(int mode)
 105 {
 106     if (S_ISREG(mode)) {
 107         return "file";
 108     }
 109     else if (S_ISDIR(mode)) {
 110         return "directory";
 111     }
 112 #ifdef S_ISCHR
 113     else if (S_ISCHR(mode)) {
 114         return "characterSpecial";
 115     }
 116 #endif
 117 #ifdef S_ISBLK
 118     else if (S_ISBLK(mode)) {
 119         return "blockSpecial";
 120     }
 121 #endif
 122 #ifdef S_ISFIFO
 123     else if (S_ISFIFO(mode)) {
 124         return "fifo";
 125     }
 126 #endif
 127 #ifdef S_ISLNK
 128     else if (S_ISLNK(mode)) {
 129         return "link";
 130     }
 131 #endif
 132 #ifdef S_ISSOCK
 133     else if (S_ISSOCK(mode)) {
 134         return "socket";
 135     }
 136 #endif
 137     return "unknown";
 138 }
 139
 140 /*
 141  *----------------------------------------------------------------------
 142  *
 143  * StoreStatData --
 144  *
 145  *  This is a utility procedure that breaks out the fields of a
 146  *  "stat" structure and stores them in textual form into the
 147  *  elements of an associative array.
 148  *
 149  * Results:
 150  *  Returns a standard Tcl return value.  If an error occurs then
 151  *  a message is left in interp->result.
 152  *
 153  * Side effects:
 154  *  Elements of the associative array given by "varName" are modified.
 155  *
 156  *----------------------------------------------------------------------
 157  */
 158 static void AppendStatElement(Jim_Interp *interp, Jim_Obj *listObj, const char *key, jim_wide value)
 159 {
 160     Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, key, -1));
 161     Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, value));
 162 }
 163
 164 static int StoreStatData(Jim_Interp *interp, Jim_Obj *varName, const struct stat *sb)
 165 {
 166     /* Just use a list to store the data */
 167     Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
 168
 169     AppendStatElement(interp, listObj, "dev", sb->st_dev);
 170     AppendStatElement(interp, listObj, "ino", sb->st_ino);
 171     AppendStatElement(interp, listObj, "mode", sb->st_mode);
 172     AppendStatElement(interp, listObj, "nlink", sb->st_nlink);
 173     AppendStatElement(interp, listObj, "uid", sb->st_uid);
 174     AppendStatElement(interp, listObj, "gid", sb->st_gid);
 175     AppendStatElement(interp, listObj, "size", sb->st_size);
 176     AppendStatElement(interp, listObj, "atime", sb->st_atime);
 177     AppendStatElement(interp, listObj, "mtime", sb->st_mtime);
 178     AppendStatElement(interp, listObj, "ctime", sb->st_ctime);
 179 #ifdef STAT_MTIME_US
 180     AppendStatElement(interp, listObj, "mtimeus", STAT_MTIME_US(*sb));
 181 #endif
 182     Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "type", -1));
 183     Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, JimGetFileType((int)sb->st_mode), -1));
 184
 185     /* Was a variable specified? */
 186     if (varName) {
 187         Jim_Obj *objPtr;
 188         objPtr = Jim_GetVariable(interp, varName, JIM_NONE);
 189
 190         if (objPtr) {
 191             Jim_Obj *objv[2];
 192
 193             objv[0] = objPtr;
 194             objv[1] = listObj;
 195
 196             objPtr = Jim_DictMerge(interp, 2, objv);
 197             if (objPtr == NULL) {
 198                 /* This message matches the one from Tcl */
 199                 Jim_SetResultFormatted(interp, "can't set \"%#s(dev)\": variable isn't array", varName);
 200                 Jim_FreeNewObj(interp, listObj);
 201                 return JIM_ERR;
 202             }
 203
 204             Jim_InvalidateStringRep(objPtr);
 205
 206             Jim_FreeNewObj(interp, listObj);
 207             listObj = objPtr;
 208         }
 209         Jim_SetVariable(interp, varName, listObj);
 210     }
 211
 212     /* And also return the value */
 213     Jim_SetResult(interp, listObj);
 214
 215     return JIM_OK;
 216 }
 217
 218 /**
 219  * Give a path of length 'len', returns the length of the path
 220  * with any trailing slashes removed.
 221  */
 222 static int JimPathLenNoTrailingSlashes(const char *path, int len)
 223 {
 224     int i;
 225     for (i = len; i > 1 && path[i - 1] == '/'; i--) {
 226         /* Trailing slash, so remove it */
 227         if (ISWINDOWS && path[i - 2] == ':') {
 228             /* But on windows, we won't remove the trailing slash from c:/ */
 229             break;
 230         }
 231     }
 232     return i;
 233 }
 234
 235 /**
 236  * Give a path in objPtr, returns a new path with any trailing slash removed.
 237  * Use Jim_DecrRefCount() on the returned object (which may be identical to objPtr).
 238  */
 239 static Jim_Obj *JimStripTrailingSlashes(Jim_Interp *interp, Jim_Obj *objPtr)
 240 {
 241     int len = Jim_Length(objPtr);
 242     const char *path = Jim_String(objPtr);
 243     int i = JimPathLenNoTrailingSlashes(path, len);
 244     if (i != len) {
 245         objPtr = Jim_NewStringObj(interp, path, i);
 246     }
 247     Jim_IncrRefCount(objPtr);
 248     return objPtr;
 249 }
 250
 251 static int file_cmd_dirname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 252 {
 253     Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
 254     const char *path = Jim_String(objPtr);
 255     const char *p = strrchr(path, '/');
 256
 257     if (!p && path[0] == '.' && path[1] == '.' && path[2] == '\0') {
 258         Jim_SetResultString(interp, "..", -1);
 259     } else if (!p) {
 260         Jim_SetResultString(interp, ".", -1);
 261     }
 262     else if (p == path) {
 263         Jim_SetResultString(interp, "/", -1);
 264     }
 265     else if (ISWINDOWS && p[-1] == ':') {
 266         /* z:/dir => z:/ */
 267         Jim_SetResultString(interp, path, p - path + 1);
 268     }
 269     else {
 270         /* Strip any trailing slashes from the result */
 271         int len = JimPathLenNoTrailingSlashes(path, p - path);
 272         Jim_SetResultString(interp, path, len);
 273     }
 274     Jim_DecrRefCount(interp, objPtr);
 275     return JIM_OK;
 276 }
 277
 278 static int file_cmd_rootname(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 279 {
 280     Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
 281     const char *path = Jim_String(objPtr);
 282     const char *lastSlash = strrchr(path, '/');
 283     const char *p = strrchr(path, '.');
 284
 285     if (p == NULL || (lastSlash != NULL && lastSlash > p)) {
 286         Jim_SetResult(interp, objPtr);
 287     }
 288     else {
 289         Jim_SetResultString(interp, path, p - path);
 290     }
 291     Jim_DecrRefCount(interp, objPtr);
 292     return JIM_OK;
 293 }
 294
 295 static int file_cmd_extension(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 296 {
 297     Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
 298     const char *path = Jim_String(objPtr);
 299     const char *lastSlash = strrchr(path, '/');
 300     const char *p = strrchr(path, '.');
 301
 302     if (p == NULL || (lastSlash != NULL && lastSlash >= p)) {
 303         p = "";
 304     }
 305     Jim_SetResultString(interp, p, -1);
 306     Jim_DecrRefCount(interp, objPtr);
 307     return JIM_OK;
 308 }
 309
 310 static int file_cmd_tail(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 311 {
 312     Jim_Obj *objPtr = JimStripTrailingSlashes(interp, argv[0]);
 313     const char *path = Jim_String(objPtr);
 314     const char *lastSlash = strrchr(path, '/');
 315
 316     if (lastSlash) {
 317         Jim_SetResultString(interp, lastSlash + 1, -1);
 318     }
 319     else {
 320         Jim_SetResult(interp, objPtr);
 321     }
 322     Jim_DecrRefCount(interp, objPtr);
 323     return JIM_OK;
 324 }
 325
 326 static int file_cmd_normalize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 327 {
 328 #ifdef HAVE_REALPATH
 329     const char *path = Jim_String(argv[0]);
 330     char *newname = Jim_Alloc(MAXPATHLEN + 1);
 331
 332     if (realpath(path, newname)) {
 333         Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, -1));
 334         return JIM_OK;
 335     }
 336     else {
 337         Jim_Free(newname);
 338         Jim_SetResultFormatted(interp, "can't normalize \"%#s\": %s", argv[0], strerror(errno));
 339         return JIM_ERR;
 340     }
 341 #else
 342     Jim_SetResultString(interp, "Not implemented", -1);
 343     return JIM_ERR;
 344 #endif
 345 }
 346
 347 static int file_cmd_join(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 348 {
 349     int i;
 350     char *newname = Jim_Alloc(MAXPATHLEN + 1);
 351     char *last = newname;
 352
 353     *newname = 0;
 354
 355     /* Simple implementation for now */
 356     for (i = 0; i < argc; i++) {
 357         int len;
 358         const char *part = Jim_GetString(argv[i], &len);
 359
 360         if (*part == '/') {
 361             /* Absolute component, so go back to the start */
 362             last = newname;
 363         }
 364         else if (ISWINDOWS && strchr(part, ':')) {
 365             /* Absolute component on mingw, so go back to the start */
 366             last = newname;
 367         }
 368         else if (part[0] == '.') {
 369             if (part[1] == '/') {
 370                 part += 2;
 371                 len -= 2;
 372             }
 373             else if (part[1] == 0 && last != newname) {
 374                 /* Adding '.' to an existing path does nothing */
 375                 continue;
 376             }
 377         }
 378
 379         /* Add a slash if needed */
 380         if (last != newname && last[-1] != '/') {
 381             *last++ = '/';
 382         }
 383
 384         if (len) {
 385             if (last + len - newname >= MAXPATHLEN) {
 386                 Jim_Free(newname);
 387                 Jim_SetResultString(interp, "Path too long", -1);
 388                 return JIM_ERR;
 389             }
 390             memcpy(last, part, len);
 391             last += len;
 392         }
 393
 394         /* Remove a slash if needed */
 395         if (last > newname + 1 && last[-1] == '/') {
 396             /* but on on Windows, leave the trailing slash on "c:/ " */
 397             if (!ISWINDOWS || !(last > newname + 2 && last[-2] == ':')) {
 398                 *--last = 0;
 399             }
 400         }
 401     }
 402
 403     *last = 0;
 404
 405     /* Probably need to handle some special cases ... */
 406
 407     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, last - newname));
 408
 409     return JIM_OK;
 410 }
 411
 412 static int file_access(Jim_Interp *interp, Jim_Obj *filename, int mode)
 413 {
 414     Jim_SetResultBool(interp, access(Jim_String(filename), mode) != -1);
 415
 416     return JIM_OK;
 417 }
 418
 419 static int file_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 420 {
 421     return file_access(interp, argv[0], R_OK);
 422 }
 423
 424 static int file_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 425 {
 426     return file_access(interp, argv[0], W_OK);
 427 }
 428
 429 static int file_cmd_executable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 430 {
 431 #ifdef X_OK
 432     return file_access(interp, argv[0], X_OK);
 433 #else
 434     /* If no X_OK, just assume true. */
 435     Jim_SetResultBool(interp, 1);
 436     return JIM_OK;
 437 #endif
 438 }
 439
 440 static int file_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 441 {
 442     return file_access(interp, argv[0], F_OK);
 443 }
 444
 445 static int file_cmd_delete(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 446 {
 447     int force = Jim_CompareStringImmediate(interp, argv[0], "-force");
 448
 449     if (force || Jim_CompareStringImmediate(interp, argv[0], "--")) {
 450         argc++;
 451         argv--;
 452     }
 453
 454     while (argc--) {
 455         const char *path = Jim_String(argv[0]);
 456
 457         if (unlink(path) == -1 && errno != ENOENT) {
 458             if (rmdir(path) == -1) {
 459                 /* Maybe try using the script helper */
 460                 if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) {
 461                     Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path,
 462                         strerror(errno));
 463                     return JIM_ERR;
 464                 }
 465             }
 466         }
 467         argv++;
 468     }
 469     return JIM_OK;
 470 }
 471
 472 #ifdef HAVE_MKDIR_ONE_ARG
 473 #define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME)
 474 #else
 475 #define MKDIR_DEFAULT(PATHNAME) mkdir(PATHNAME, 0755)
 476 #endif
 477
 478 /**
 479  * Create directory, creating all intermediate paths if necessary.
 480  *
 481  * Returns 0 if OK or -1 on failure (and sets errno)
 482  *
 483  * Note: The path may be modified.
 484  */
 485 static int mkdir_all(char *path)
 486 {
 487     int ok = 1;
 488
 489     /* First time just try to make the dir */
 490     goto first;
 491
 492     while (ok--) {
 493         /* Must have failed the first time, so recursively make the parent and try again */
 494         {
 495             char *slash = strrchr(path, '/');
 496
 497             if (slash && slash != path) {
 498                 *slash = 0;
 499                 if (mkdir_all(path) != 0) {
 500                     return -1;
 501                 }
 502                 *slash = '/';
 503             }
 504         }
 505       first:
 506         if (MKDIR_DEFAULT(path) == 0) {
 507             return 0;
 508         }
 509         if (errno == ENOENT) {
 510             /* Create the parent and try again */
 511             continue;
 512         }
 513         /* Maybe it already exists as a directory */
 514         if (errno == EEXIST) {
 515             struct stat sb;
 516
 517             if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) {
 518                 return 0;
 519             }
 520             /* Restore errno */
 521             errno = EEXIST;
 522         }
 523         /* Failed */
 524         break;
 525     }
 526     return -1;
 527 }
 528
 529 static int file_cmd_mkdir(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 530 {
 531     while (argc--) {
 532         char *path = Jim_StrDup(Jim_String(argv[0]));
 533         int rc = mkdir_all(path);
 534
 535         Jim_Free(path);
 536         if (rc != 0) {
 537             Jim_SetResultFormatted(interp, "can't create directory \"%#s\": %s", argv[0],
 538                 strerror(errno));
 539             return JIM_ERR;
 540         }
 541         argv++;
 542     }
 543     return JIM_OK;
 544 }
 545
 546 static int file_cmd_tempfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 547 {
 548     int fd = Jim_MakeTempFile(interp, (argc >= 1) ? Jim_String(argv[0]) : NULL, 0);
 549
 550     if (fd < 0) {
 551         return JIM_ERR;
 552     }
 553     close(fd);
 554
 555     return JIM_OK;
 556 }
 557
 558 static int file_cmd_rename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 559 {
 560     const char *source;
 561     const char *dest;
 562     int force = 0;
 563
 564     if (argc == 3) {
 565         if (!Jim_CompareStringImmediate(interp, argv[0], "-force")) {
 566             return -1;
 567         }
 568         force++;
 569         argv++;
 570         argc--;
 571     }
 572
 573     source = Jim_String(argv[0]);
 574     dest = Jim_String(argv[1]);
 575
 576     if (!force && access(dest, F_OK) == 0) {
 577         Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": target exists", argv[0],
 578             argv[1]);
 579         return JIM_ERR;
 580     }
 581
 582     if (rename(source, dest) != 0) {
 583         Jim_SetResultFormatted(interp, "error renaming \"%#s\" to \"%#s\": %s", argv[0], argv[1],
 584             strerror(errno));
 585         return JIM_ERR;
 586     }
 587
 588     return JIM_OK;
 589 }
 590
 591 #if defined(HAVE_LINK) && defined(HAVE_SYMLINK)
 592 static int file_cmd_link(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 593 {
 594     int ret;
 595     const char *source;
 596     const char *dest;
 597     static const char * const options[] = { "-hard", "-symbolic", NULL };
 598     enum { OPT_HARD, OPT_SYMBOLIC, };
 599     int option = OPT_HARD;
 600
 601     if (argc == 3) {
 602         if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ENUM_ABBREV | JIM_ERRMSG) != JIM_OK) {
 603             return JIM_ERR;
 604         }
 605         argv++;
 606         argc--;
 607     }
 608
 609     dest = Jim_String(argv[0]);
 610     source = Jim_String(argv[1]);
 611
 612     if (option == OPT_HARD) {
 613         ret = link(source, dest);
 614     }
 615     else {
 616         ret = symlink(source, dest);
 617     }
 618
 619     if (ret != 0) {
 620         Jim_SetResultFormatted(interp, "error linking \"%#s\" to \"%#s\": %s", argv[0], argv[1],
 621             strerror(errno));
 622         return JIM_ERR;
 623     }
 624
 625     return JIM_OK;
 626 }
 627 #endif
 628
 629 static int file_stat(Jim_Interp *interp, Jim_Obj *filename, struct stat *sb)
 630 {
 631     const char *path = Jim_String(filename);
 632
 633     if (stat(path, sb) == -1) {
 634         Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
 635         return JIM_ERR;
 636     }
 637     return JIM_OK;
 638 }
 639
 640 #ifdef HAVE_LSTAT
 641 static int file_lstat(Jim_Interp *interp, Jim_Obj *filename, struct stat *sb)
 642 {
 643     const char *path = Jim_String(filename);
 644
 645     if (lstat(path, sb) == -1) {
 646         Jim_SetResultFormatted(interp, "could not read \"%#s\": %s", filename, strerror(errno));
 647         return JIM_ERR;
 648     }
 649     return JIM_OK;
 650 }
 651 #else
 652 #define file_lstat file_stat
 653 #endif
 654
 655 static int file_cmd_atime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 656 {
 657     struct stat sb;
 658
 659     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 660         return JIM_ERR;
 661     }
 662     Jim_SetResultInt(interp, sb.st_atime);
 663     return JIM_OK;
 664 }
 665
 666 /**
 667  * Set file atime/mtime to the given time in microseconds since the epoch.
 668  */
 669 static int JimSetFileTimes(Jim_Interp *interp, const char *filename, jim_wide us)
 670 {
 671 #ifdef HAVE_UTIMES
 672     struct timeval times[2];
 673
 674     times[1].tv_sec = times[0].tv_sec = us / 1000000;
 675     times[1].tv_usec = times[0].tv_usec = us % 1000000;
 676
 677     if (utimes(filename, times) != 0) {
 678         Jim_SetResultFormatted(interp, "can't set time on \"%s\": %s", filename, strerror(errno));
 679         return JIM_ERR;
 680     }
 681     return JIM_OK;
 682 #else
 683     Jim_SetResultString(interp, "Not implemented", -1);
 684     return JIM_ERR;
 685 #endif
 686 }
 687
 688 static int file_cmd_mtime(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 689 {
 690     struct stat sb;
 691
 692     if (argc == 2) {
 693         jim_wide secs;
 694         if (Jim_GetWide(interp, argv[1], &secs) != JIM_OK) {
 695             return JIM_ERR;
 696         }
 697         return JimSetFileTimes(interp, Jim_String(argv[0]), secs * 1000000);
 698     }
 699     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 700         return JIM_ERR;
 701     }
 702     Jim_SetResultInt(interp, sb.st_mtime);
 703     return JIM_OK;
 704 }
 705
 706 #ifdef STAT_MTIME_US
 707 static int file_cmd_mtimeus(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 708 {
 709     struct stat sb;
 710
 711     if (argc == 2) {
 712         jim_wide us;
 713         if (Jim_GetWide(interp, argv[1], &us) != JIM_OK) {
 714             return JIM_ERR;
 715         }
 716         return JimSetFileTimes(interp, Jim_String(argv[0]), us);
 717     }
 718     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 719         return JIM_ERR;
 720     }
 721     Jim_SetResultInt(interp, STAT_MTIME_US(sb));
 722     return JIM_OK;
 723 }
 724 #endif
 725
 726 static int file_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 727 {
 728     return Jim_EvalPrefix(interp, "file copy", argc, argv);
 729 }
 730
 731 static int file_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 732 {
 733     struct stat sb;
 734
 735     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 736         return JIM_ERR;
 737     }
 738     Jim_SetResultInt(interp, sb.st_size);
 739     return JIM_OK;
 740 }
 741
 742 static int file_cmd_isdirectory(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 743 {
 744     struct stat sb;
 745     int ret = 0;
 746
 747     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 748         ret = S_ISDIR(sb.st_mode);
 749     }
 750     Jim_SetResultInt(interp, ret);
 751     return JIM_OK;
 752 }
 753
 754 static int file_cmd_isfile(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 755 {
 756     struct stat sb;
 757     int ret = 0;
 758
 759     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 760         ret = S_ISREG(sb.st_mode);
 761     }
 762     Jim_SetResultInt(interp, ret);
 763     return JIM_OK;
 764 }
 765
 766 #ifdef HAVE_GETEUID
 767 static int file_cmd_owned(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 768 {
 769     struct stat sb;
 770     int ret = 0;
 771
 772     if (file_stat(interp, argv[0], &sb) == JIM_OK) {
 773         ret = (geteuid() == sb.st_uid);
 774     }
 775     Jim_SetResultInt(interp, ret);
 776     return JIM_OK;
 777 }
 778 #endif
 779
 780 #if defined(HAVE_READLINK)
 781 static int file_cmd_readlink(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 782 {
 783     const char *path = Jim_String(argv[0]);
 784     char *linkValue = Jim_Alloc(MAXPATHLEN + 1);
 785
 786     int linkLength = readlink(path, linkValue, MAXPATHLEN);
 787
 788     if (linkLength == -1) {
 789         Jim_Free(linkValue);
 790         Jim_SetResultFormatted(interp, "couldn't readlink \"%#s\": %s", argv[0], strerror(errno));
 791         return JIM_ERR;
 792     }
 793     linkValue[linkLength] = 0;
 794     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, linkValue, linkLength));
 795     return JIM_OK;
 796 }
 797 #endif
 798
 799 static int file_cmd_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 800 {
 801     struct stat sb;
 802
 803     if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
 804         return JIM_ERR;
 805     }
 806     Jim_SetResultString(interp, JimGetFileType((int)sb.st_mode), -1);
 807     return JIM_OK;
 808 }
 809
 810 #ifdef HAVE_LSTAT
 811 static int file_cmd_lstat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 812 {
 813     struct stat sb;
 814
 815     if (file_lstat(interp, argv[0], &sb) != JIM_OK) {
 816         return JIM_ERR;
 817     }
 818     return StoreStatData(interp, argc == 2 ? argv[1] : NULL, &sb);
 819 }
 820 #else
 821 #define file_cmd_lstat file_cmd_stat
 822 #endif
 823
 824 static int file_cmd_stat(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 825 {
 826     struct stat sb;
 827
 828     if (file_stat(interp, argv[0], &sb) != JIM_OK) {
 829         return JIM_ERR;
 830     }
 831     return StoreStatData(interp, argc == 2 ? argv[1] : NULL, &sb);
 832 }
 833
 834 static const jim_subcmd_type file_command_table[] = {
 835     {   "atime",
 836         "name",
 837         file_cmd_atime,
 838         1,
 839         1,
 840         /* Description: Last access time */
 841     },
 842     {   "mtime",
 843         "name ?time?",
 844         file_cmd_mtime,
 845         1,
 846         2,
 847         /* Description: Get or set last modification time */
 848     },
 849 #ifdef STAT_MTIME_US
 850     {   "mtimeus",
 851         "name ?time?",
 852         file_cmd_mtimeus,
 853         1,
 854         2,
 855         /* Description: Get or set last modification time in microseconds */
 856     },
 857 #endif
 858     {   "copy",
 859         "?-force? source dest",
 860         file_cmd_copy,
 861         2,
 862         3,
 863         /* Description: Copy source file to destination file */
 864     },
 865     {   "dirname",
 866         "name",
 867         file_cmd_dirname,
 868         1,
 869         1,
 870         /* Description: Directory part of the name */
 871     },
 872     {   "rootname",
 873         "name",
 874         file_cmd_rootname,
 875         1,
 876         1,
 877         /* Description: Name without any extension */
 878     },
 879     {   "extension",
 880         "name",
 881         file_cmd_extension,
 882         1,
 883         1,
 884         /* Description: Last extension including the dot */
 885     },
 886     {   "tail",
 887         "name",
 888         file_cmd_tail,
 889         1,
 890         1,
 891         /* Description: Last component of the name */
 892     },
 893     {   "normalize",
 894         "name",
 895         file_cmd_normalize,
 896         1,
 897         1,
 898         /* Description: Normalized path of name */
 899     },
 900     {   "join",
 901         "name ?name ...?",
 902         file_cmd_join,
 903         1,
 904         -1,
 905         /* Description: Join multiple path components */
 906     },
 907     {   "readable",
 908         "name",
 909         file_cmd_readable,
 910         1,
 911         1,
 912         /* Description: Is file readable */
 913     },
 914     {   "writable",
 915         "name",
 916         file_cmd_writable,
 917         1,
 918         1,
 919         /* Description: Is file writable */
 920     },
 921     {   "executable",
 922         "name",
 923         file_cmd_executable,
 924         1,
 925         1,
 926         /* Description: Is file executable */
 927     },
 928     {   "exists",
 929         "name",
 930         file_cmd_exists,
 931         1,
 932         1,
 933         /* Description: Does file exist */
 934     },
 935     {   "delete",
 936         "?-force|--? name ...",
 937         file_cmd_delete,
 938         1,
 939         -1,
 940         /* Description: Deletes the files or directories (must be empty unless -force) */
 941     },
 942     {   "mkdir",
 943         "dir ...",
 944         file_cmd_mkdir,
 945         1,
 946         -1,
 947         /* Description: Creates the directories */
 948     },
 949     {   "tempfile",
 950         "?template?",
 951         file_cmd_tempfile,
 952         0,
 953         1,
 954         /* Description: Creates a temporary filename */
 955     },
 956     {   "rename",
 957         "?-force? source dest",
 958         file_cmd_rename,
 959         2,
 960         3,
 961         /* Description: Renames a file */
 962     },
 963 #if defined(HAVE_LINK) && defined(HAVE_SYMLINK)
 964     {   "link",
 965         "?-symbolic|-hard? newname target",
 966         file_cmd_link,
 967         2,
 968         3,
 969         /* Description: Creates a hard or soft link */
 970     },
 971 #endif
 972 #if defined(HAVE_READLINK)
 973     {   "readlink",
 974         "name",
 975         file_cmd_readlink,
 976         1,
 977         1,
 978         /* Description: Value of the symbolic link */
 979     },
 980 #endif
 981     {   "size",
 982         "name",
 983         file_cmd_size,
 984         1,
 985         1,
 986         /* Description: Size of file */
 987     },
 988     {   "stat",
 989         "name ?var?",
 990         file_cmd_stat,
 991         1,
 992         2,
 993         /* Description: Returns results of stat, and may store in var array */
 994     },
 995     {   "lstat",
 996         "name ?var?",
 997         file_cmd_lstat,
 998         1,
 999         2,
1000         /* Description: Returns results of lstat, and may store in var array */
1001     },
1002     {   "type",
1003         "name",
1004         file_cmd_type,
1005         1,
1006         1,
1007         /* Description: Returns type of the file */
1008     },
1009 #ifdef HAVE_GETEUID
1010     {   "owned",
1011         "name",
1012         file_cmd_owned,
1013         1,
1014         1,
1015         /* Description: Returns 1 if owned by the current owner */
1016     },
1017 #endif
1018     {   "isdirectory",
1019         "name",
1020         file_cmd_isdirectory,
1021         1,
1022         1,
1023         /* Description: Returns 1 if name is a directory */
1024     },
1025     {   "isfile",
1026         "name",
1027         file_cmd_isfile,
1028         1,
1029         1,
1030         /* Description: Returns 1 if name is a file */
1031     },
1032     {
1033         NULL
1034     }
1035 };
1036
1037 static int Jim_CdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1038 {
1039     const char *path;
1040
1041     if (argc != 2) {
1042         Jim_WrongNumArgs(interp, 1, argv, "dirname");
1043         return JIM_ERR;
1044     }
1045
1046     path = Jim_String(argv[1]);
1047
1048     if (chdir(path) != 0) {
1049         Jim_SetResultFormatted(interp, "couldn't change working directory to \"%s\": %s", path,
1050             strerror(errno));
1051         return JIM_ERR;
1052     }
1053     return JIM_OK;
1054 }
1055
1056 static int Jim_PwdCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1057 {
1058     char *cwd = Jim_Alloc(MAXPATHLEN);
1059
1060     if (getcwd(cwd, MAXPATHLEN) == NULL) {
1061         Jim_SetResultString(interp, "Failed to get pwd", -1);
1062         Jim_Free(cwd);
1063         return JIM_ERR;
1064     }
1065     else if (ISWINDOWS) {
1066         /* Try to keep backslashes out of paths */
1067         char *p = cwd;
1068         while ((p = strchr(p, '\\')) != NULL) {
1069             *p++ = '/';
1070         }
1071     }
1072
1073     Jim_SetResultString(interp, cwd, -1);
1074
1075     Jim_Free(cwd);
1076     return JIM_OK;
1077 }
1078
1079 int Jim_fileInit(Jim_Interp *interp)
1080 {
1081     if (Jim_PackageProvide(interp, "file", "1.0", JIM_ERRMSG))
1082         return JIM_ERR;
1083
1084     Jim_CreateCommand(interp, "file", Jim_SubCmdProc, (void *)file_command_table, NULL);
1085     Jim_CreateCommand(interp, "pwd", Jim_PwdCmd, NULL, NULL);
1086     Jim_CreateCommand(interp, "cd", Jim_CdCmd, NULL, NULL);
1087     return JIM_OK;
1088 }