diff options
Diffstat (limited to 'src/file.c')
| -rw-r--r-- | src/file.c | 3166 |
1 files changed, 3166 insertions, 0 deletions
diff --git a/src/file.c b/src/file.c new file mode 100644 index 0000000..c4fb2bb --- /dev/null +++ b/src/file.c @@ -0,0 +1,3166 @@ +/* +** Copyright (c) 2006 D. Richard Hipp +** +** This program is free software; you can redistribute it and/or +** modify it under the terms of the Simplified BSD License (also +** known as the "2-Clause License" or "FreeBSD License".) +** +** This program is distributed in the hope that it will be useful, +** but without any warranty; without even the implied warranty of +** merchantability or fitness for a particular purpose. +** +** Author contact information: +** drh@hwaci.com +** http://www.hwaci.com/drh/ +** +******************************************************************************* +** +** File utilities. +*/ +#include "config.h" +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <time.h> +#include "file.h" + +/* +** On Windows, include the Platform SDK header file. +*/ +#ifdef _WIN32 +# include <direct.h> +# include <windows.h> +# include <sys/utime.h> +#else +# include <sys/time.h> +# include <pwd.h> +# include <grp.h> +#endif + +#if INTERFACE + +/* Many APIs take an eFType argument which must be one of ExtFILE, RepoFILE, +** or SymFILE. +** +** The difference is in the handling of symbolic links. RepoFILE should be +** used for files that are under management by a Fossil repository. ExtFILE +** should be used for files that are not under management. SymFILE is for +** a few special cases such as the "fossil test-tarball" command when we never +** want to follow symlinks. +** +** ExtFILE Symbolic links always refer to the object to which the +** link points. Symlinks are never recognized as symlinks but +** instead always appear to be the target object. +** +** SymFILE Symbolic links always appear to be files whose name is +** the target pathname of the symbolic link. +** +** RepoFILE Like SymFILE if allow-symlinks is true, or like +** ExtFILE if allow-symlinks is false. In other words, +** symbolic links are only recognized as something different +** from files or directories if allow-symlinks is true. +*/ +#include <stdlib.h> +#define ExtFILE 0 /* Always follow symlinks */ +#define RepoFILE 1 /* Follow symlinks if and only if allow-symlinks is OFF */ +#define SymFILE 2 /* Never follow symlinks */ + +#include <dirent.h> +#if defined(_WIN32) +# define DIR _WDIR +# define dirent _wdirent +# define opendir _wopendir +# define readdir _wreaddir +# define closedir _wclosedir +#endif /* _WIN32 */ + +#if defined(_WIN32) && (defined(__MSVCRT__) || defined(_MSC_VER)) +/* +** File status information for windows systems. +*/ +struct fossilStat { + i64 st_size; + i64 st_mtime; + int st_mode; +}; +#endif + +#if defined(_WIN32) || defined(__CYGWIN__) +# define fossil_isdirsep(a) (((a) == '/') || ((a) == '\\')) +#else +# define fossil_isdirsep(a) ((a) == '/') +#endif + +#endif /* INTERFACE */ + +#if !defined(_WIN32) || !(defined(__MSVCRT__) || defined(_MSC_VER)) +/* +** File status information for unix systems +*/ +# define fossilStat stat +#endif + +/* +** On Windows S_ISLNK always returns FALSE. +*/ +#if !defined(S_ISLNK) +# define S_ISLNK(x) (0) +#endif + +/* +** Local state information for the file status routines +*/ +static struct { + struct fossilStat fileStat; /* File status from last fossil_stat() */ + int fileStatValid; /* True if fileStat is valid */ +} fx; + +/* +** Fill *buf with information about zFilename. +** +** If zFilename refers to a symbolic link: +** +** (A) If allow-symlinks is on and eFType is RepoFILE, then fill +** *buf with information about the symbolic link itself. +** +** (B) If allow-symlinks is off or eFType is ExtFILE, then fill +** *buf with information about the object that the symbolic link +** points to. +*/ +static int fossil_stat( + const char *zFilename, /* name of file or directory to inspect. */ + struct fossilStat *buf, /* pointer to buffer where info should go. */ + int eFType /* Look at symlink itself if RepoFILE and enabled. */ +){ + int rc; + void *zMbcs = fossil_utf8_to_path(zFilename, 0); +#if !defined(_WIN32) + if( (eFType==RepoFILE && db_allow_symlinks()) + || eFType==SymFILE ){ + /* Symlinks look like files whose content is the name of the target */ + rc = lstat(zMbcs, buf); + }else{ + /* Symlinks look like the object to which they point */ + rc = stat(zMbcs, buf); + } +#else + rc = win32_stat(zMbcs, buf, eFType); +#endif + fossil_path_free(zMbcs); + return rc; +} + +/* +** Clears the fx.fileStat variable and its associated validity flag. +*/ +static void resetStat(){ + fx.fileStatValid = 0; + memset(&fx.fileStat, 0, sizeof(struct fossilStat)); +} + +/* +** Fill in the fx.fileStat variable for the file named zFilename. +** If zFilename==0, then use the previous value of fx.fileStat if +** there is a previous value. +** +** Return the number of errors. No error messages are generated. +*/ +static int getStat(const char *zFilename, int eFType){ + int rc = 0; + if( zFilename==0 ){ + if( fx.fileStatValid==0 ) rc = 1; + }else{ + if( fossil_stat(zFilename, &fx.fileStat, eFType)!=0 ){ + fx.fileStatValid = 0; + rc = 1; + }else{ + fx.fileStatValid = 1; + rc = 0; + } + } + return rc; +} + +/* +** Return the size of a file in bytes. Return -1 if the file does not +** exist. If zFilename is NULL, return the size of the most recently +** stat-ed file. +*/ +i64 file_size(const char *zFilename, int eFType){ + return getStat(zFilename, eFType) ? -1 : fx.fileStat.st_size; +} + +/* +** Return the modification time for a file. Return -1 if the file +** does not exist. If zFilename is NULL return the size of the most +** recently stat-ed file. +*/ +i64 file_mtime(const char *zFilename, int eFType){ + return getStat(zFilename, eFType) ? -1 : fx.fileStat.st_mtime; +} + +/* +** Return the mode bits for a file. Return -1 if the file does not +** exist. If zFilename is NULL return the size of the most recently +** stat-ed file. +*/ +int file_mode(const char *zFilename, int eFType){ + return getStat(zFilename, eFType) ? -1 : (int)(fx.fileStat.st_mode); +} + +/* +** Return TRUE if either of the following are true: +** +** (1) zFilename is an ordinary file +** +** (2) allow_symlinks is on and zFilename is a symbolic link to +** a file, directory, or other object +*/ +int file_isfile_or_link(const char *zFilename){ + if( getStat(zFilename, RepoFILE) ){ + return 0; /* stat() failed. Return false. */ + } + return S_ISREG(fx.fileStat.st_mode) || S_ISLNK(fx.fileStat.st_mode); +} + +/* +** Return TRUE if the named file is an ordinary file. Return false +** for directories, devices, fifos, symlinks, etc. +*/ +int file_isfile(const char *zFilename, int eFType){ + return getStat(zFilename, eFType) ? 0 : S_ISREG(fx.fileStat.st_mode); +} + +/* +** Return TRUE if zFilename is a socket. +*/ +int file_issocket(const char *zFilename){ +#ifdef _WIN32 + return 0; +#else + if( getStat(zFilename, ExtFILE) ){ + return 0; /* stat() failed. Return false. */ + } + return S_ISSOCK(fx.fileStat.st_mode); +#endif +} + +/* +** Create a symbolic link named zLinkFile that points to zTargetFile. +** +** If allow-symlinks is off, create an ordinary file named zLinkFile +** with the name of zTargetFile as its content. +**/ +void symlink_create(const char *zTargetFile, const char *zLinkFile){ +#if !defined(_WIN32) + if( db_allow_symlinks() ){ + int i, nName; + char *zName, zBuf[1000]; + + nName = strlen(zLinkFile); + if( nName>=(int)sizeof(zBuf) ){ + zName = fossil_strdup(zLinkFile); + }else{ + zName = zBuf; + memcpy(zName, zLinkFile, nName+1); + } + nName = file_simplify_name(zName, nName, 0); + for(i=1; i<nName; i++){ + if( zName[i]=='/' ){ + zName[i] = 0; + if( file_mkdir(zName, ExtFILE, 1) ){ + fossil_fatal_recursive("unable to create directory %s", zName); + return; + } + zName[i] = '/'; + } + } + if( symlink(zTargetFile, zName)!=0 ){ + fossil_fatal_recursive("unable to create symlink \"%s\"", zName); + } + if( zName!=zBuf ) free(zName); + }else +#endif + { + Blob content; + blob_set(&content, zTargetFile); + blob_write_to_file(&content, zLinkFile); + blob_reset(&content); + } +} + +/* +** Copy symbolic link from zFrom to zTo. +*/ +void symlink_copy(const char *zFrom, const char *zTo){ + Blob content; + blob_read_link(&content, zFrom); + symlink_create(blob_str(&content), zTo); + blob_reset(&content); +} + +/* +** Return file permissions (normal, executable, or symlink): +** - PERM_EXE on Unix if file is executable; +** - PERM_LNK on Unix if file is symlink and allow-symlinks option is on; +** - PERM_REG for all other cases (regular file, directory, fifo, etc). +** +** If eFType is ExtFile then symbolic links are followed and so this +** routine can only return PERM_EXE and PERM_REG. +** +** On windows, this routine returns only PERM_REG. +*/ +int file_perm(const char *zFilename, int eFType){ +#if !defined(_WIN32) + if( !getStat(zFilename, eFType) ){ + if( S_ISREG(fx.fileStat.st_mode) && ((S_IXUSR)&fx.fileStat.st_mode)!=0 ) + return PERM_EXE; + else if( db_allow_symlinks() && S_ISLNK(fx.fileStat.st_mode) ) + return PERM_LNK; + } +#endif + return PERM_REG; +} + +/* +** Return TRUE if the named file is an executable. Return false +** for directories, devices, fifos, symlinks, etc. +*/ +int file_isexe(const char *zFilename, int eFType){ + return file_perm(zFilename, eFType)==PERM_EXE; +} + +/* +** Return TRUE if the named file is a symlink and symlinks are allowed. +** Return false for all other cases. +** +** This routines assumes RepoFILE - that zFilename is always a file +** under management. +** +** On Windows, always return False. +*/ +int file_islink(const char *zFilename){ + return file_perm(zFilename, RepoFILE)==PERM_LNK; +} + +/* +** Check every sub-directory of zRoot along the path to zFile. +** If any sub-directory is really an ordinary file or a symbolic link, +** return an integer which is the length of the prefix of zFile which +** is the name of that object. Return 0 if all no non-directory +** objects are found along the path. +** +** Example: Given inputs +** +** zRoot = /home/alice/project1 +** zFile = /home/alice/project1/main/src/js/fileA.js +** +** Look for objects in the following order: +** +** /home/alice/project/main +** /home/alice/project/main/src +** /home/alice/project/main/src/js +** +** If any of those objects exist and are something other than a directory +** then return the length of the name of the first non-directory object +** seen. +*/ +int file_nondir_objects_on_path(const char *zRoot, const char *zFile){ + int i = (int)strlen(zRoot); + char *z = fossil_strdup(zFile); + assert( fossil_strnicmp(zRoot, z, i)==0 ); + if( i && zRoot[i-1]=='/' ) i--; + while( z[i]=='/' ){ + int j, rc; + for(j=i+1; z[j] && z[j]!='/'; j++){} + if( z[j]!='/' ) break; + z[j] = 0; + rc = file_isdir(z, SymFILE); + if( rc!=1 ){ + if( rc==2 ){ + fossil_free(z); + return j; + } + break; + } + z[j] = '/'; + i = j; + } + fossil_free(z); + return 0; +} + +/* +** The file named zFile is suppose to be an in-tree file. Check to +** ensure that it will be safe to write to this file by verifying that +** there are no symlinks or other non-directory objects in between the +** root of the check-out and zFile. +** +** If a problem is found, print a warning message (using fossil_warning()) +** and return non-zero. If everything is ok, return zero. +*/ +int file_unsafe_in_tree_path(const char *zFile){ + int n; + if( !file_is_absolute_path(zFile) ){ + fossil_fatal("%s is not an absolute pathname",zFile); + } + if( fossil_strnicmp(g.zLocalRoot, zFile, (int)strlen(g.zLocalRoot)) ){ + fossil_fatal("%s is not a prefix of %s", g.zLocalRoot, zFile); + } + n = file_nondir_objects_on_path(g.zLocalRoot, zFile); + if( n ){ + fossil_warning("cannot write to %s because non-directory object %.*s" + " is in the way", zFile, n, zFile); + } + return n; +} + +/* +** Return 1 if zFilename is a directory. Return 0 if zFilename +** does not exist. Return 2 if zFilename exists but is something +** other than a directory. +*/ +int file_isdir(const char *zFilename, int eFType){ + int rc; + char *zFN; + + zFN = fossil_strdup(zFilename); + file_simplify_name(zFN, -1, 0); + rc = getStat(zFN, eFType); + if( rc ){ + rc = 0; /* It does not exist at all. */ + }else if( S_ISDIR(fx.fileStat.st_mode) ){ + rc = 1; /* It exists and is a real directory. */ + }else{ + rc = 2; /* It exists and is something else. */ + } + free(zFN); + return rc; +} + +/* +** Return true (1) if zFilename seems like it seems like a valid +** repository database. +*/ +int file_is_repository(const char *zFilename){ + i64 sz; + sqlite3 *db = 0; + sqlite3_stmt *pStmt = 0; + int rc; + int i; + static const char *azReqTab[] = { + "blob", "delta", "rcvfrom", "user", "config" + }; + if( !file_isfile(zFilename, ExtFILE) ) return 0; + sz = file_size(zFilename, ExtFILE); + if( sz<35328 ) return 0; + if( sz%512!=0 ) return 0; + rc = sqlite3_open_v2(zFilename, &db, + SQLITE_OPEN_READWRITE, 0); + if( rc!=0 ) goto not_a_repo; + for(i=0; i<count(azReqTab); i++){ + if( sqlite3_table_column_metadata(db, "main", azReqTab[i],0,0,0,0,0,0) ){ + goto not_a_repo; + } + } + rc = sqlite3_prepare_v2(db, "SELECT 1 FROM config WHERE name='project-code'", + -1, &pStmt, 0); + if( rc ) goto not_a_repo; + rc = sqlite3_step(pStmt); + if( rc!=SQLITE_ROW ) goto not_a_repo; + sqlite3_finalize(pStmt); + sqlite3_close(db); + return 1; + +not_a_repo: + sqlite3_finalize(pStmt); + sqlite3_close(db); + return 0; +} + + +/* +** Wrapper around the access() system call. +*/ +int file_access(const char *zFilename, int flags){ + int rc; + void *zMbcs = fossil_utf8_to_path(zFilename, 0); +#ifdef _WIN32 + rc = win32_access(zMbcs, flags); +#else + rc = access(zMbcs, flags); +#endif + fossil_path_free(zMbcs); + return rc; +} + +/* +** Wrapper around the chdir() system call. +** If bChroot=1, do a chroot to this dir as well +** (UNIX only) +*/ +int file_chdir(const char *zChDir, int bChroot){ + int rc; + void *zPath = fossil_utf8_to_path(zChDir, 1); +#ifdef _WIN32 + rc = win32_chdir(zPath, bChroot); +#else + rc = chdir(zPath); + if( !rc && bChroot ){ + rc = chroot(zPath); + if( !rc ) rc = chdir("/"); + g.fJail = 1; + } +#endif + fossil_path_free(zPath); + return rc; +} + +/* +** Find an unused filename similar to zBase with zSuffix appended. +** +** Make the name relative to the working directory if relFlag is true. +** +** Space to hold the new filename is obtained form mprintf() and should +** be freed by the caller. +*/ +char *file_newname(const char *zBase, const char *zSuffix, int relFlag){ + char *z = 0; + int cnt = 0; + z = mprintf("%s-%s", zBase, zSuffix); + while( file_size(z, ExtFILE)>=0 ){ + fossil_free(z); + z = mprintf("%s-%s-%d", zBase, zSuffix, cnt++); + } + if( relFlag ){ + Blob x; + file_relative_name(z, &x, 0); + fossil_free(z); + z = blob_str(&x); + } + return z; +} + +/* +** Return the tail of a file pathname. The tail is the last component +** of the path. For example, the tail of "/a/b/c.d" is "c.d". +*/ +const char *file_tail(const char *z){ + const char *zTail = z; + if( !zTail ) return 0; + while( z[0] ){ + if( fossil_isdirsep(z[0]) ) zTail = &z[1]; + z++; + } + return zTail; +} + +/* +** Return the tail of a command: the basename of the putative executable (which +** could be quoted when containing spaces) and the following arguments. +*/ +const char *command_tail(const char *z){ + const char *zTail = z; + char chQuote = 0; + if( !zTail ) return 0; + while( z[0] && (!fossil_isspace(z[0]) || chQuote) ){ + if( z[0]=='"' || z[0]=='\'' ){ + chQuote = (chQuote==z[0]) ? 0 : z[0]; + } + if( fossil_isdirsep(z[0]) ) zTail = &z[1]; + z++; + } + return zTail; +} + +/* +** Return the directory of a file path name. The directory is all components +** except the last one. For example, the directory of "/a/b/c.d" is "/a/b". +** If there is no directory, NULL is returned; otherwise, the returned memory +** should be freed via fossil_free(). +*/ +char *file_dirname(const char *z){ + const char *zTail = file_tail(z); + if( zTail && zTail!=z ){ + return mprintf("%.*s", (int)(zTail-z-1), z); + }else{ + return 0; + } +} + +/* +** Return the basename of the putative executable in a command (w/o arguments). +** The returned memory should be freed via fossil_free(). +*/ +char *command_basename(const char *z){ + const char *zTail = command_tail(z); + const char *zEnd = zTail; + while( zEnd[0] && !fossil_isspace(zEnd[0]) && zEnd[0]!='"' && zEnd[0]!='\'' ){ + zEnd++; + } + if( zEnd ){ + return mprintf("%.*s", (int)(zEnd-zTail), zTail); + }else{ + return 0; + } +} + +/* SQL Function: file_dirname(NAME) +** +** Return the directory for NAME +*/ +void file_dirname_sql_function( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName = (const char*)sqlite3_value_text(argv[0]); + char *zDir; + if( zName==0 ) return; + zDir = file_dirname(zName); + if( zDir ){ + sqlite3_result_text(context,zDir,-1,fossil_free); + } +} + + +/* +** Rename a file or directory. +** Returns zero upon success. +*/ +int file_rename( + const char *zFrom, + const char *zTo, + int isFromDir, + int isToDir +){ + int rc; +#if defined(_WIN32) + wchar_t *zMbcsFrom = fossil_utf8_to_path(zFrom, isFromDir); + wchar_t *zMbcsTo = fossil_utf8_to_path(zTo, isToDir); + rc = _wrename(zMbcsFrom, zMbcsTo); +#else + char *zMbcsFrom = fossil_utf8_to_path(zFrom, isFromDir); + char *zMbcsTo = fossil_utf8_to_path(zTo, isToDir); + rc = rename(zMbcsFrom, zMbcsTo); +#endif + fossil_path_free(zMbcsTo); + fossil_path_free(zMbcsFrom); + return rc; +} + +/* +** Copy the content of a file from one place to another. +*/ +void file_copy(const char *zFrom, const char *zTo){ + FILE *in, *out; + int got; + char zBuf[8192]; + in = fossil_fopen(zFrom, "rb"); + if( in==0 ) fossil_fatal("cannot open \"%s\" for reading", zFrom); + file_mkfolder(zTo, ExtFILE, 0, 0); + out = fossil_fopen(zTo, "wb"); + if( out==0 ) fossil_fatal("cannot open \"%s\" for writing", zTo); + while( (got=fread(zBuf, 1, sizeof(zBuf), in))>0 ){ + fwrite(zBuf, 1, got, out); + } + fclose(in); + fclose(out); + if( file_isexe(zFrom, ExtFILE) ) file_setexe(zTo, 1); +} + +/* +** COMMAND: test-file-copy +** +** Usage: %fossil test-file-copy SOURCE DESTINATION +** +** Make a copy of the file at SOURCE into a new name DESTINATION. Any +** directories in the path leading up to DESTINATION that do not already +** exist are created automatically. +*/ +void test_file_copy(void){ + if( g.argc!=4 ){ + fossil_fatal("Usage: %s test-file-copy SOURCE DESTINATION", g.argv[0]); + } + file_copy(g.argv[2], g.argv[3]); +} + +/* +** Set or clear the execute bit on a file. Return true if a change +** occurred and false if this routine is a no-op. +** +** This routine assumes RepoFILE as the eFType. In other words, if +** zFilename is a symbolic link, it is the object that zFilename points +** to that is modified. +*/ +int file_setexe(const char *zFilename, int onoff){ + int rc = 0; +#if !defined(_WIN32) + struct stat buf; + if( fossil_stat(zFilename, &buf, RepoFILE)!=0 + || S_ISLNK(buf.st_mode) + || S_ISDIR(buf.st_mode) + ){ + return 0; + } + if( onoff ){ + int targetMode = (buf.st_mode & 0444)>>2; + if( (buf.st_mode & 0100)==0 ){ + chmod(zFilename, buf.st_mode | targetMode); + rc = 1; + } + }else{ + if( (buf.st_mode & 0100)!=0 ){ + chmod(zFilename, buf.st_mode & ~0111); + rc = 1; + } + } +#endif /* _WIN32 */ + return rc; +} + +/* +** Set the mtime for a file. +*/ +void file_set_mtime(const char *zFilename, i64 newMTime){ +#if !defined(_WIN32) + char *zMbcs; + struct timeval tv[2]; + memset(tv, 0, sizeof(tv[0])*2); + tv[0].tv_sec = newMTime; + tv[1].tv_sec = newMTime; + zMbcs = fossil_utf8_to_path(zFilename, 0); + utimes(zMbcs, tv); +#else + struct _utimbuf tb; + wchar_t *zMbcs = fossil_utf8_to_path(zFilename, 0); + tb.actime = newMTime; + tb.modtime = newMTime; + _wutime(zMbcs, &tb); +#endif + fossil_path_free(zMbcs); +} + +/* +** COMMAND: test-set-mtime +** +** Usage: %fossil test-set-mtime FILENAME DATE/TIME +** +** Sets the mtime of the named file to the date/time shown. +*/ +void test_set_mtime(void){ + const char *zFile; + char *zDate; + i64 iMTime; + if( g.argc!=4 ){ + usage("FILENAME DATE/TIME"); + } + db_open_or_attach(":memory:", "mem"); + iMTime = db_int64(0, "SELECT strftime('%%s',%Q)", g.argv[3]); + zFile = g.argv[2]; + file_set_mtime(zFile, iMTime); + iMTime = file_mtime(zFile, RepoFILE); + zDate = db_text(0, "SELECT datetime(%lld, 'unixepoch')", iMTime); + fossil_print("Set mtime of \"%s\" to %s (%lld)\n", zFile, zDate, iMTime); +} + +/* +** Change access permissions on a file. +*/ +void file_set_mode(const char *zFN, int fd, const char *zMode, int bNoErr){ +#if !defined(_WIN32) + mode_t m; + char *zEnd = 0; + m = strtol(zMode, &zEnd, 0); + if( (zEnd[0] || fchmod(fd, m)) && !bNoErr ){ + fossil_fatal("cannot change permissions on %s to \"%s\"", + zFN, zMode); + } +#endif +} + +/* Change the owner of a file to zOwner. zOwner can be of the form +** USER:GROUP. +*/ +void file_set_owner(const char *zFN, int fd, const char *zOwner){ +#if !defined(_WIN32) + const char *zGrp; + const char *zUsr = zOwner; + struct passwd *pw; + struct group *grp; + uid_t uid = -1; + gid_t gid = -1; + zGrp = strchr(zUsr, ':'); + if( zGrp ){ + int n = (int)(zGrp - zUsr); + zUsr = fossil_strndup(zUsr, n); + zGrp++; + } + pw = getpwnam(zUsr); + if( pw==0 ){ + fossil_fatal("no such user: \"%s\"", zUsr); + } + uid = pw->pw_uid; + if( zGrp ){ + grp = getgrnam(zGrp); + if( grp==0 ){ + fossil_fatal("no such group: \"%s\"", zGrp); + } + gid = grp->gr_gid; + } + if( chown(zFN, uid, gid) ){ + fossil_fatal("cannot change ownership of %s to %s",zFN, zOwner); + } + if( zOwner!=zUsr ){ + fossil_free((char*)zUsr); + } +#endif +} + + +/* +** Delete a file. +** +** If zFilename is a symbolic link, then it is the link itself that is +** removed, not the object that zFilename points to. +** +** Returns zero upon success. +*/ +int file_delete(const char *zFilename){ + int rc; +#ifdef _WIN32 + wchar_t *z = fossil_utf8_to_path(zFilename, 0); + rc = _wunlink(z); +#else + char *z = fossil_utf8_to_path(zFilename, 0); + rc = unlink(zFilename); +#endif + fossil_path_free(z); + return rc; +} + +/* SQL Function: file_delete(NAME) +** +** Remove file NAME. Return zero on success and non-zero if anything goes +** wrong. +*/ +void file_delete_sql_function( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName = (const char*)sqlite3_value_text(argv[0]); + int rc; + if( zName==0 ){ + rc = 1; + }else{ + rc = file_delete(zName); + } + sqlite3_result_int(context, rc); +} + +/* +** Create a directory called zName, if it does not already exist. +** If forceFlag is 1, delete any prior non-directory object +** with the same name. +** +** Return the number of errors. +*/ +int file_mkdir(const char *zName, int eFType, int forceFlag){ + int rc = file_isdir(zName, eFType); + if( rc==2 ){ + if( !forceFlag ) return 1; + file_delete(zName); + } + if( rc!=1 ){ +#if defined(_WIN32) + wchar_t *zMbcs = fossil_utf8_to_path(zName, 1); + rc = _wmkdir(zMbcs); +#else + char *zMbcs = fossil_utf8_to_path(zName, 1); + rc = mkdir(zMbcs, 0755); +#endif + fossil_path_free(zMbcs); + return rc; + } + return 0; +} + +/* +** Create the tree of directories in which zFilename belongs, if that sequence +** of directories does not already exist. +** +** On success, return zero. On error, return errorReturn if positive, otherwise +** print an error message and abort. +*/ +int file_mkfolder( + const char *zFilename, /* Pathname showing directories to be created */ + int eFType, /* Follow symlinks if ExtFILE */ + int forceFlag, /* Delete non-directory objects in the way */ + int errorReturn /* What to do when an error is seen */ +){ + int nName, rc = 0; + char *zName; + + nName = strlen(zFilename); + zName = fossil_strdup(zFilename); + nName = file_simplify_name(zName, nName, 0); + while( nName>0 && zName[nName-1]!='/' ){ nName--; } + if( nName>1 ){ + zName[nName-1] = 0; + if( file_isdir(zName, eFType)!=1 ){ + rc = file_mkfolder(zName, eFType, forceFlag, errorReturn); + if( rc==0 ){ + if( file_mkdir(zName, eFType, forceFlag) + && file_isdir(zName, eFType)!=1 + ){ + if( errorReturn <= 0 ){ + fossil_fatal_recursive("unable to create directory %s", zName); + } + rc = errorReturn; + } + } + } + } + free(zName); + return rc; +} + +#if defined(_WIN32) +/* +** Returns non-zero if the specified name represents a real directory, i.e. +** not a junction or symbolic link. This is important for some operations, +** e.g. removing directories via _wrmdir(), because its detection of empty +** directories will (apparently) not work right for junctions and symbolic +** links, etc. +*/ +int file_is_normal_dir(wchar_t *zName){ + /* + ** Mask off attributes, applicable to directories, that are harmless for + ** our purposes. This may need to be updated if other attributes should + ** be ignored by this function. + */ + DWORD dwAttributes = GetFileAttributesW(zName); + if( dwAttributes==INVALID_FILE_ATTRIBUTES ) return 0; + dwAttributes &= ~( + FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_COMPRESSED | + FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_NORMAL | + FILE_ATTRIBUTE_NOT_CONTENT_INDEXED + ); + return dwAttributes==FILE_ATTRIBUTE_DIRECTORY; +} + +/* +** COMMAND: test-is-normal-dir +** +** Usage: %fossil test-is-normal-dir NAME... +** +** Returns non-zero if the specified names represent real directories, i.e. +** not junctions, symbolic links, etc. +*/ +void test_is_normal_dir(void){ + int i; + for(i=2; i<g.argc; i++){ + wchar_t *zMbcs = fossil_utf8_to_path(g.argv[i], 1); + fossil_print("ATTRS \"%s\" -> %lx\n", g.argv[i], GetFileAttributesW(zMbcs)); + fossil_print("ISDIR \"%s\" -> %d\n", g.argv[i], file_is_normal_dir(zMbcs)); + fossil_path_free(zMbcs); + } +} +#endif + +/* +** Removes the directory named in the argument, if it exists. The directory +** must be empty and cannot be the current directory or the root directory. +** +** Returns zero upon success. +*/ +int file_rmdir(const char *zName){ + int rc = file_isdir(zName, RepoFILE); + if( rc==2 ) return 1; /* cannot remove normal file */ + if( rc==1 ){ +#if defined(_WIN32) + wchar_t *zMbcs = fossil_utf8_to_path(zName, 1); + if( file_is_normal_dir(zMbcs) ){ + rc = _wrmdir(zMbcs); + }else{ + rc = ENOTDIR; /* junction, symbolic link, etc. */ + } +#else + char *zMbcs = fossil_utf8_to_path(zName, 1); + rc = rmdir(zName); +#endif + fossil_path_free(zMbcs); + return rc; + } + return 0; +} + +/* SQL Function: rmdir(NAME) +** +** Try to remove the directory NAME. Return zero on success and non-zero +** for failure. +*/ +void file_rmdir_sql_function( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName = (const char*)sqlite3_value_text(argv[0]); + int rc; + if( zName==0 ){ + rc = 1; + }else{ + rc = file_rmdir(zName); + } + sqlite3_result_int(context, rc); +} + +/* +** Check the input argument to see if it looks like it has an prefix that +** indicates a remote file. If so, return the tail of the specification, +** which is the name of the file on the remote system. +** +** If the input argument does not have a prefix that makes it look like +** a remote file reference, then return NULL. +** +** Remote files look like: "HOST:PATH" or "USER@HOST:PATH". Host must +** be a valid hostname, meaning it must follow these rules: +** +** * Only characters [-.a-zA-Z0-9]. No spaces or other punctuation +** * Does not begin or end with - +** * Name is two or more characters long (otherwise it might be +** confused with a drive-letter on Windows). +** +** The USER section, if it exists, must not contain the '@' character. +*/ +const char *file_skip_userhost(const char *zIn){ + const char *zTail; + int n, i; + if( zIn[0]==':' ) return 0; + zTail = strchr(zIn, ':'); + if( zTail==0 ) return 0; + if( zTail - zIn > 10000 ) return 0; + n = (int)(zTail - zIn); + if( n<2 ) return 0; + if( zIn[n-1]=='-' || zIn[n-1]=='.' ) return 0; + for(i=n-1; i>0 && zIn[i-1]!='@'; i--){ + if( !fossil_isalnum(zIn[i]) && zIn[i]!='-' && zIn[i]!='.' ) return 0; + } + if( zIn[i]=='-' || zIn[i]=='.' || i==1 ) return 0; + if( i>1 ){ + i -= 2; + while( i>=0 ){ + if( zIn[i]=='@' ) return 0; + i--; + } + } + return zTail+1; +} + +/* +** Return true if the filename given is a valid filename for +** a file in a repository. Valid filenames follow all of the +** following rules: +** +** * Does not begin with "/" +** * Does not contain any path element named "." or ".." +** * Does not contain any of these characters in the path: "\" +** * Does not end with "/". +** * Does not contain two or more "/" characters in a row. +** * Contains at least one character +** +** Invalid UTF8 characters result in a false return if bStrictUtf8 is +** true. If bStrictUtf8 is false, invalid UTF8 characters are silently +** ignored. See http://en.wikipedia.org/wiki/UTF-8#Invalid_byte_sequences +** and http://en.wikipedia.org/wiki/Unicode (for the noncharacters) +** +** The bStrictUtf8 flag is true for new inputs, but is false when parsing +** legacy manifests, for backwards compatibility. +*/ +int file_is_simple_pathname(const char *z, int bStrictUtf8){ + int i; + unsigned char c = (unsigned char) z[0]; + char maskNonAscii = bStrictUtf8 ? 0x80 : 0x00; + if( c=='/' || c==0 ) return 0; + if( c=='.' ){ + if( z[1]=='/' || z[1]==0 ) return 0; + if( z[1]=='.' && (z[2]=='/' || z[2]==0) ) return 0; + } + for(i=0; (c=(unsigned char)z[i])!=0; i++){ + if( c & maskNonAscii ){ + if( (z[++i]&0xc0)!=0x80 ){ + /* Invalid first continuation byte */ + return 0; + } + if( c<0xc2 ){ + /* Invalid 1-byte UTF-8 sequence, or 2-byte overlong form. */ + return 0; + }else if( (c&0xe0)==0xe0 ){ + /* 3-byte or more */ + int unicode; + if( c&0x10 ){ + /* Unicode characters > U+FFFF are not supported. + * Windows XP and earlier cannot handle them. + */ + return 0; + } + /* This is a 3-byte UTF-8 character */ + unicode = ((c&0x0f)<<12) + ((z[i]&0x3f)<<6) + (z[i+1]&0x3f); + if( unicode <= 0x07ff ){ + /* overlong form */ + return 0; + }else if( unicode>=0xe000 ){ + /* U+E000..U+FFFF */ + if( (unicode<=0xf8ff) || (unicode>=0xfffe) ){ + /* U+E000..U+F8FF are for private use. + * U+FFFE..U+FFFF are noncharacters. */ + return 0; + } else if( (unicode>=0xfdd0) && (unicode<=0xfdef) ){ + /* U+FDD0..U+FDEF are noncharacters. */ + return 0; + } + }else if( (unicode>=0xd800) && (unicode<=0xdfff) ){ + /* U+D800..U+DFFF are for surrogate pairs. */ + return 0; + } + if( (z[++i]&0xc0)!=0x80 ){ + /* Invalid second continuation byte */ + return 0; + } + } + }else if( bStrictUtf8 && (c=='\\') ){ + return 0; + } + if( c=='/' ){ + if( z[i+1]=='/' ) return 0; + if( z[i+1]=='.' ){ + if( z[i+2]=='/' || z[i+2]==0 ) return 0; + if( z[i+2]=='.' && (z[i+3]=='/' || z[i+3]==0) ) return 0; + } + } + } + if( z[i-1]=='/' ) return 0; + return 1; +} +int file_is_simple_pathname_nonstrict(const char *z){ + unsigned char c = (unsigned char) z[0]; + if( c=='/' || c==0 ) return 0; + if( c=='.' ){ + if( z[1]=='/' || z[1]==0 ) return 0; + if( z[1]=='.' && (z[2]=='/' || z[2]==0) ) return 0; + } + while( (z = strchr(z+1, '/'))!=0 ){ + if( z[1]=='/' ) return 0; + if( z[1]==0 ) return 0; + if( z[1]=='.' ){ + if( z[2]=='/' || z[2]==0 ) return 0; + if( z[2]=='.' && (z[3]=='/' || z[3]==0) ) return 0; + } + } + return 1; +} + +/* +** If the last component of the pathname in z[0]..z[j-1] is something +** other than ".." then back it out and return true. If the last +** component is empty or if it is ".." then return false. +*/ +static int backup_dir(const char *z, int *pJ){ + int j = *pJ; + int i; + if( j<=0 ) return 0; + for(i=j-1; i>0 && z[i-1]!='/'; i--){} + if( z[i]=='.' && i==j-2 && z[i+1]=='.' ) return 0; + *pJ = i-1; + return 1; +} + +/* +** Simplify a filename by +** +** * Remove extended path prefix on windows and cygwin +** * Convert all \ into / on windows and cygwin +** * removing any trailing and duplicate / +** * removing /./ +** * removing /A/../ +** +** Changes are made in-place. Return the new name length. +** If the slash parameter is non-zero, the trailing slash, if any, +** is retained. +*/ +int file_simplify_name(char *z, int n, int slash){ + int i = 1, j; + assert( z!=0 ); + if( n<0 ) n = strlen(z); + if( n==0 ) return 0; + + /* On windows and cygwin convert all \ characters to / + * and remove extended path prefix if present */ +#if defined(_WIN32) || defined(__CYGWIN__) + for(j=0; j<n; j++){ + if( z[j]=='\\' ) z[j] = '/'; + } + if( n>3 && !memcmp(z, "//?/", 4) ){ + if( fossil_strnicmp(z+4,"UNC", 3) ){ + i += 4; + z[0] = z[4]; + }else{ + i += 6; + z[0] = '/'; + } + } +#endif + + /* Removing trailing "/" characters */ + if( !slash ){ + while( n>1 && z[n-1]=='/' ){ n--; } + } + + /* Remove duplicate '/' characters. Except, two // at the beginning + ** of a pathname is allowed since this is important on windows. */ + for(j=1; i<n; i++){ + z[j++] = z[i]; + while( z[i]=='/' && i<n-1 && z[i+1]=='/' ) i++; + } + n = j; + + /* Skip over zero or more initial "./" sequences */ + for(i=0; i<n-1 && z[i]=='.' && z[i+1]=='/'; i+=2){} + + /* Begin copying from z[i] back to z[j]... */ + for(j=0; i<n; i++){ + if( z[i]=='/' ){ + /* Skip over internal "/." directory components */ + if( z[i+1]=='.' && (i+2==n || z[i+2]=='/') ){ + i += 1; + continue; + } + + /* If this is a "/.." directory component then back out the + ** previous term of the directory if it is something other than ".." + ** or "." + */ + if( z[i+1]=='.' && i+2<n && z[i+2]=='.' && (i+3==n || z[i+3]=='/') + && backup_dir(z, &j) + ){ + i += 2; + continue; + } + } + if( j>=0 ) z[j] = z[i]; + j++; + } + if( j==0 ) z[j++] = '/'; + z[j] = 0; + return j; +} + +/* +** COMMAND: test-simplify-name +** +** Usage: %fossil test-simplify-name FILENAME... +** +** Print the simplified versions of each FILENAME. This is used to test +** the file_simplify_name() routine. +** +** If FILENAME is of the form "HOST:PATH" or "USER@HOST:PATH", then remove +** and print the remote host prefix first. This is used to test the +** file_skip_userhost() interface. +*/ +void cmd_test_simplify_name(void){ + int i; + char *z; + const char *zTail; + for(i=2; i<g.argc; i++){ + zTail = file_skip_userhost(g.argv[i]); + if( zTail ){ + fossil_print("... ON REMOTE: %.*s\n", (int)(zTail-g.argv[i]), g.argv[i]); + z = fossil_strdup(zTail); + }else{ + z = fossil_strdup(g.argv[i]); + } + fossil_print("[%s] -> ", z); + file_simplify_name(z, -1, 0); + fossil_print("[%s]\n", z); + fossil_free(z); + } +} + +/* +** Get the current working directory. +** +** On windows, the name is converted from unicode to UTF8 and all '\\' +** characters are converted to '/'. No conversions are needed on +** unix. +** +** Store the value of the CWD in zBuf which is nBuf bytes in size. +** or if zBuf==0, allocate space to hold the result using fossil_malloc(). +*/ +char *file_getcwd(char *zBuf, int nBuf){ + if( zBuf==0 ){ + char zTemp[2000]; + return fossil_strdup(file_getcwd(zTemp, sizeof(zTemp))); + } +#ifdef _WIN32 + win32_getcwd(zBuf, nBuf); +#else + if( getcwd(zBuf, nBuf-1)==0 ){ + if( errno==ERANGE ){ + fossil_fatal("pwd too big: max %d", nBuf-1); + }else{ + fossil_fatal("cannot find current working directory; %s", + strerror(errno)); + } + } +#endif + return zBuf; +} + +/* +** Return true if zPath is an absolute pathname. Return false +** if it is relative. +*/ +int file_is_absolute_path(const char *zPath){ + if( fossil_isdirsep(zPath[0]) +#if defined(_WIN32) || defined(__CYGWIN__) + || (fossil_isalpha(zPath[0]) && zPath[1]==':' + && (fossil_isdirsep(zPath[2]) || zPath[2]=='\0')) +#endif + ){ + return 1; + }else{ + return 0; + } +} + +/* +** Compute a canonical pathname for a file or directory. +** +** * Make the name absolute if it is relative. +** * Remove redundant / characters +** * Remove all /./ path elements. +** * Convert /A/../ to just / +** * On windows, add the drive letter prefix. +** +** If the slash parameter is non-zero, the trailing slash, if any, +** is retained. +** +** See also: file_canonical_name_dup() +*/ +void file_canonical_name(const char *zOrigName, Blob *pOut, int slash){ + char zPwd[2000]; + blob_zero(pOut); + if( file_is_absolute_path(zOrigName) ){ +#if defined(_WIN32) + if( fossil_isdirsep(zOrigName[0]) ){ + /* Add the drive letter to the full pathname */ + file_getcwd(zPwd, sizeof(zPwd)-strlen(zOrigName)); + blob_appendf(pOut, "%.2s%/", zPwd, zOrigName); + }else +#endif + { + blob_appendf(pOut, "%/", zOrigName); + } + }else{ + file_getcwd(zPwd, sizeof(zPwd)-strlen(zOrigName)); + if( zPwd[0]=='/' && strlen(zPwd)==1 ){ + /* when on '/', don't add an extra '/' */ + if( zOrigName[0]=='.' && strlen(zOrigName)==1 ){ + /* '.' when on '/' mean '/' */ + blob_appendf(pOut, "%/", zPwd); + }else{ + blob_appendf(pOut, "%/%/", zPwd, zOrigName); + } + }else{ + blob_appendf(pOut, "%//%/", zPwd, zOrigName); + } + } +#if defined(_WIN32) || defined(__CYGWIN__) + { + char *zOut; + /* + ** On Windows/cygwin, normalize the drive letter to upper case. + */ + zOut = blob_str(pOut); + if( fossil_islower(zOut[0]) && zOut[1]==':' && zOut[2]=='/' ){ + zOut[0] = fossil_toupper(zOut[0]); + } + } +#endif + blob_resize(pOut, file_simplify_name(blob_buffer(pOut), + blob_size(pOut), slash)); +} + +/* +** Compute the canonical name of a file. Store that name in +** memory obtained from fossil_malloc() and return a pointer to the +** name. +** +** See also: file_canonical_name() +*/ +char *file_canonical_name_dup(const char *zOrigName){ + Blob x; + if( zOrigName==0 ) return 0; + blob_init(&x, 0, 0); + file_canonical_name(zOrigName, &x, 0); + return blob_str(&x); +} + +/* +** Convert zPath, which is a relative pathname rooted at zDir, into the +** case preferred by the underlying filesystem. Return the a copy +** of the converted path in memory obtained from fossil_malloc(). +** +** For case-sensitive filesystems, such as on Linux, this routine is +** just fossil_strdup(). But for case-insenstiive but "case preserving" +** filesystems, such as on MacOS or Windows, we want the filename to be +** in the preserved casing. That's what this routine does. +*/ +char *file_case_preferred_name(const char *zDir, const char *zPath){ +#ifndef _WIN32 /* Call win32_file_case_preferred_name() on Windows. */ + DIR *d; + int i; + char *zResult = 0; + void *zNative = 0; + + if( filenames_are_case_sensitive() ){ + return fossil_strdup(zPath); + } + for(i=0; zPath[i] && zPath[i]!='/' && zPath[i]!='\\'; i++){} + zNative = fossil_utf8_to_path(zDir, 1); + d = opendir(zNative); + if( d ){ + struct dirent *pEntry; + while( (pEntry = readdir(d))!=0 ){ + char *zUtf8 = fossil_path_to_utf8(pEntry->d_name); + if( fossil_strnicmp(zUtf8, zPath, i)==0 && zUtf8[i]==0 ){ + if( zPath[i]==0 ){ + zResult = fossil_strdup(zUtf8); + }else{ + char *zSubDir = mprintf("%s/%s", zDir, zUtf8); + char *zSubPath = file_case_preferred_name(zSubDir, &zPath[i+1]); + zResult = mprintf("%s/%s", zUtf8, zSubPath); + fossil_free(zSubPath); + fossil_free(zSubDir); + } + fossil_path_free(zUtf8); + break; + } + fossil_path_free(zUtf8); + } + closedir(d); + } + fossil_path_free(zNative); + if( zResult==0 ) zResult = fossil_strdup(zPath); + return zResult; +#else /* !_WIN32 */ + return win32_file_case_preferred_name(zDir,zPath); +#endif /* !_WIN32 */ +} + +/* +** COMMAND: test-case-filename +** +** Usage: fossil test-case-filename DIRECTORY PATH PATH PATH .... +** +** All the PATH arguments (there must be one at least one) are pathnames +** relative to DIRECTORY. This test command prints the OS-preferred name +** for each PATH in filesystems where case is not significant. +*/ +void test_preferred_fn(void){ + int i; + if( g.argc<4 ){ + usage("DIRECTORY PATH ..."); + } + for(i=3; i<g.argc; i++){ + char *z = file_case_preferred_name(g.argv[2], g.argv[i]); + fossil_print("%s -> %s\n", g.argv[i], z); + fossil_free(z); + } +} + +/* +** The input is the name of an executable, such as one might +** type on a command-line. This routine resolves that name into +** a full pathname. The result is obtained from fossil_malloc() +** and should be freed by the caller. +*/ +char *file_fullexename(const char *zCmd){ +#ifdef _WIN32 + char *zPath; + char *z = 0; + const char *zExe = ""; + if( sqlite3_strlike("%.exe",zCmd,0)!=0 ) zExe = ".exe"; + if( file_is_absolute_path(zCmd) ){ + return mprintf("%s%s", zCmd, zExe); + } + if( strchr(zCmd,'\\')!=0 && strchr(zCmd,'/')!=0 ){ + int i; + Blob out = BLOB_INITIALIZER; + file_canonical_name(zCmd, &out, 0); + blob_append(&out, zExe, -1); + z = fossil_strdup(blob_str(&out)); + blob_reset(&out); + for(i=0; z[i]; i++){ if( z[i]=='/' ) z[i] = '\\'; } + return z; + } + z = mprintf(".\\%s%s", zCmd, zExe); + if( file_isfile(z, ExtFILE) ){ + int i; + Blob out = BLOB_INITIALIZER; + file_canonical_name(zCmd, &out, 0); + blob_append(&out, zExe, -1); + z = fossil_strdup(blob_str(&out)); + blob_reset(&out); + for(i=0; z[i]; i++){ if( z[i]=='/' ) z[i] = '\\'; } + return z; + } + fossil_free(z); + zPath = fossil_getenv("PATH"); + while( zPath && zPath[0] ){ + int n; + char *zColon; + zColon = strchr(zPath, ';'); + n = zColon ? (int)(zColon-zPath) : (int)strlen(zPath); + while( n>0 && zPath[n-1]=='\\' ){ n--; } + z = mprintf("%.*s\\%s%s", n, zPath, zCmd, zExe); + if( file_isfile(z, ExtFILE) ){ + return z; + } + fossil_free(z); + if( zColon==0 ) break; + zPath = zColon+1; + } + return fossil_strdup(zCmd); +#else + char *zPath; + char *z; + if( zCmd[0]=='/' ){ + return fossil_strdup(zCmd); + } + if( strchr(zCmd,'/')!=0 ){ + Blob out = BLOB_INITIALIZER; + file_canonical_name(zCmd, &out, 0); + z = fossil_strdup(blob_str(&out)); + blob_reset(&out); + return z; + } + zPath = fossil_getenv("PATH"); + while( zPath && zPath[0] ){ + int n; + char *zColon; + zColon = strchr(zPath, ':'); + n = zColon ? (int)(zColon-zPath) : (int)strlen(zPath); + z = mprintf("%.*s/%s", n, zPath, zCmd); + if( file_isexe(z, ExtFILE) ){ + return z; + } + fossil_free(z); + if( zColon==0 ) break; + zPath = zColon+1; + } + return fossil_strdup(zCmd); +#endif +} + +/* +** COMMAND: test-which +** +** Usage: %fossil test-which ARGS... +** +** For each argument, search the PATH for the executable with the name +** and print its full pathname. +** +** See also the "which" command (without the "test-" prefix). The plain +** "which" command is more convenient to use since it provides the -a/-all +** option, and because it is shorter. The "fossil which" command without +** the "test-" prefix is recommended for day-to-day use. This command is +** retained because it tests the internal file_fullexename() function +** whereas plain "which" does not. +*/ +void test_which_cmd(void){ + int i; + for(i=2; i<g.argc; i++){ + char *z = file_fullexename(g.argv[i]); + fossil_print("%z\n", z); + } +} + +/* +** Emits the effective or raw stat() information for the specified +** file or directory, optionally preserving the trailing slash and +** resetting the cached stat() information. +*/ +static void emitFileStat( + const char *zPath, + int slash, + int reset +){ + char zBuf[200]; + char *z; + Blob x; + char *zFull; + int rc; + sqlite3_int64 iMtime; + struct fossilStat testFileStat; + memset(zBuf, 0, sizeof(zBuf)); + blob_zero(&x); + file_canonical_name(zPath, &x, slash); + zFull = blob_str(&x); + fossil_print("[%s] -> [%s]\n", zPath, zFull); + memset(&testFileStat, 0, sizeof(struct fossilStat)); + rc = fossil_stat(zPath, &testFileStat, 0); + fossil_print(" stat_rc = %d\n", rc); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", testFileStat.st_size); + fossil_print(" stat_size = %s\n", zBuf); + if( g.db==0 ) sqlite3_open(":memory:", &g.db); + z = db_text(0, "SELECT datetime(%lld, 'unixepoch')", testFileStat.st_mtime); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld (%s)", testFileStat.st_mtime, z); + fossil_free(z); + fossil_print(" stat_mtime = %s\n", zBuf); + fossil_print(" stat_mode = 0%o\n", testFileStat.st_mode); + memset(&testFileStat, 0, sizeof(struct fossilStat)); + rc = fossil_stat(zPath, &testFileStat, 1); + fossil_print(" l_stat_rc = %d\n", rc); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", testFileStat.st_size); + fossil_print(" l_stat_size = %s\n", zBuf); + z = db_text(0, "SELECT datetime(%lld, 'unixepoch')", testFileStat.st_mtime); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld (%s)", testFileStat.st_mtime, z); + fossil_free(z); + fossil_print(" l_stat_mtime = %s\n", zBuf); + fossil_print(" l_stat_mode = 0%o\n", testFileStat.st_mode); + if( reset ) resetStat(); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_size(zPath,ExtFILE)); + fossil_print(" file_size(ExtFILE) = %s\n", zBuf); + iMtime = file_mtime(zPath, ExtFILE); + z = db_text(0, "SELECT datetime(%lld, 'unixepoch')", iMtime); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld (%s)", iMtime, z); + fossil_free(z); + fossil_print(" file_mtime(ExtFILE) = %s\n", zBuf); + fossil_print(" file_mode(ExtFILE) = 0%o\n", file_mode(zPath,ExtFILE)); + fossil_print(" file_isfile(ExtFILE) = %d\n", file_isfile(zPath,ExtFILE)); + fossil_print(" file_isdir(ExtFILE) = %d\n", file_isdir(zPath,ExtFILE)); + fossil_print(" file_issocket() = %d\n", file_issocket(zPath)); + if( reset ) resetStat(); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_size(zPath,RepoFILE)); + fossil_print(" file_size(RepoFILE) = %s\n", zBuf); + iMtime = file_mtime(zPath,RepoFILE); + z = db_text(0, "SELECT datetime(%lld, 'unixepoch')", iMtime); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld (%s)", iMtime, z); + fossil_free(z); + fossil_print(" file_mtime(RepoFILE) = %s\n", zBuf); + fossil_print(" file_mode(RepoFILE) = 0%o\n", file_mode(zPath,RepoFILE)); + fossil_print(" file_isfile(RepoFILE) = %d\n", file_isfile(zPath,RepoFILE)); + fossil_print(" file_isfile_or_link = %d\n", file_isfile_or_link(zPath)); + fossil_print(" file_islink = %d\n", file_islink(zPath)); + fossil_print(" file_isexe(RepoFILE) = %d\n", file_isexe(zPath,RepoFILE)); + fossil_print(" file_isdir(RepoFILE) = %d\n", file_isdir(zPath,RepoFILE)); + fossil_print(" file_is_repository = %d\n", file_is_repository(zPath)); + fossil_print(" file_is_reserved_name = %d\n", + file_is_reserved_name(zFull,-1)); + fossil_print(" file_in_cwd = %d\n", file_in_cwd(zPath)); + blob_reset(&x); + if( reset ) resetStat(); +} + +/* +** COMMAND: test-file-environment +** +** Usage: %fossil test-file-environment FILENAME... +** +** Display the effective file handling subsystem "settings" and then +** display file system information about the files specified, if any. +** +** Options: +** --allow-symlinks BOOLEAN Temporarily turn allow-symlinks on/off +** --open-config Open the configuration database first +** --reset Reset cached stat() info for each file +** --root ROOT Use ROOT as the root of the check-out +** --slash Trailing slashes, if any, are retained +*/ +void cmd_test_file_environment(void){ + int i; + int slashFlag = find_option("slash",0,0)!=0; + int resetFlag = find_option("reset",0,0)!=0; + const char *zRoot = find_option("root",0,1); + const char *zAllow = find_option("allow-symlinks",0,1); + if( find_option("open-config", 0, 0)!=0 ){ + Th_OpenConfig(1); + } + db_find_and_open_repository(OPEN_ANY_SCHEMA|OPEN_OK_NOT_FOUND, 0); + fossil_print("filenames_are_case_sensitive() = %d\n", + filenames_are_case_sensitive()); + if( zAllow ){ + g.allowSymlinks = !is_false(zAllow); + } + if( zRoot==0 ) zRoot = g.zLocalRoot==0 ? "" : g.zLocalRoot; + fossil_print("db_allow_symlinks() = %d\n", db_allow_symlinks()); + fossil_print("local-root = [%s]\n", zRoot); + if( g.db==0 ) sqlite3_open(":memory:", &g.db); + sqlite3_create_function(g.db, "inode", 1, SQLITE_UTF8, 0, + file_inode_sql_func, 0, 0); + for(i=2; i<g.argc; i++){ + char *z; + emitFileStat(g.argv[i], slashFlag, resetFlag); + z = file_canonical_name_dup(g.argv[i]); + fossil_print(" file_canonical_name = %s\n", z); + fossil_print(" file_nondir_path = "); + if( fossil_strnicmp(zRoot,z,(int)strlen(zRoot))!=0 ){ + fossil_print("(--root is not a prefix of this file)\n"); + }else{ + int n = file_nondir_objects_on_path(zRoot, z); + fossil_print("%.*s\n", n, z); + } + fossil_free(z); + z = db_text(0, "SELECT inode(%Q)", g.argv[i]); + fossil_print(" file_inode_sql_func = \"%s\"\n", z); + fossil_free(z); + } +} + +/* +** COMMAND: test-canonical-name +** +** Usage: %fossil test-canonical-name FILENAME... +** +** Test the operation of the canonical name generator. +** Also test Fossil's ability to measure attributes of a file. +*/ +void cmd_test_canonical_name(void){ + int i; + Blob x; + int slashFlag = find_option("slash",0,0)!=0; + blob_zero(&x); + for(i=2; i<g.argc; i++){ + char zBuf[100]; + const char *zName = g.argv[i]; + file_canonical_name(zName, &x, slashFlag); + fossil_print("[%s] -> [%s]\n", zName, blob_buffer(&x)); + blob_reset(&x); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_size(zName,RepoFILE)); + fossil_print(" file_size = %s\n", zBuf); + sqlite3_snprintf(sizeof(zBuf), zBuf, "%lld", file_mtime(zName,RepoFILE)); + fossil_print(" file_mtime = %s\n", zBuf); + fossil_print(" file_isfile = %d\n", file_isfile(zName,RepoFILE)); + fossil_print(" file_isfile_or_link = %d\n", file_isfile_or_link(zName)); + fossil_print(" file_islink = %d\n", file_islink(zName)); + fossil_print(" file_isexe = %d\n", file_isexe(zName,RepoFILE)); + fossil_print(" file_isdir = %d\n", file_isdir(zName,RepoFILE)); + } +} + +/* +** Return TRUE if the given filename is canonical. +** +** Canonical names are full pathnames using "/" not "\" and which +** contain no "/./" or "/../" terms. +*/ +int file_is_canonical(const char *z){ + int i; + if( +#if defined(_WIN32) || defined(__CYGWIN__) + !fossil_isupper(z[0]) || z[1]!=':' || !fossil_isdirsep(z[2]) +#else + z[0]!='/' +#endif + ) return 0; + + for(i=0; z[i]; i++){ + if( z[i]=='\\' ) return 0; + if( z[i]=='/' ){ + if( z[i+1]=='.' ){ + if( z[i+2]=='/' || z[i+2]==0 ) return 0; + if( z[i+2]=='.' && (z[i+3]=='/' || z[i+3]==0) ) return 0; + } + } + } + return 1; +} + +/* +** Return a pointer to the first character in a pathname past the +** drive letter. This routine is a no-op on unix. +*/ +char *file_without_drive_letter(char *zIn){ +#ifdef _WIN32 + if( fossil_isalpha(zIn[0]) && zIn[1]==':' ) zIn += 2; +#endif + return zIn; +} + +/* +** Compute a pathname for a file or directory that is relative +** to the current directory. If the slash parameter is non-zero, +** the trailing slash, if any, is retained. +*/ +void file_relative_name(const char *zOrigName, Blob *pOut, int slash){ + char *zPath; + blob_set(pOut, zOrigName); + blob_resize(pOut, file_simplify_name(blob_buffer(pOut), + blob_size(pOut), slash)); + zPath = file_without_drive_letter(blob_buffer(pOut)); + if( zPath[0]=='/' ){ + int i, j; + Blob tmp; + char *zPwd; + char zBuf[2000]; + zPwd = zBuf; + file_getcwd(zBuf, sizeof(zBuf)-20); + zPwd = file_without_drive_letter(zBuf); + i = 1; +#if defined(_WIN32) || defined(__CYGWIN__) + while( zPath[i] && fossil_tolower(zPwd[i])==fossil_tolower(zPath[i]) ) i++; +#else + while( zPath[i] && zPwd[i]==zPath[i] ) i++; +#endif + if( zPath[i]==0 ){ + memcpy(&tmp, pOut, sizeof(tmp)); + if( zPwd[i]==0 ){ + blob_set(pOut, "."); + }else{ + blob_set(pOut, ".."); + for(j=i+1; zPwd[j]; j++){ + if( zPwd[j]=='/' ){ + blob_append(pOut, "/..", 3); + } + } + while( i>0 && (zPwd[i]!='/')) --i; + blob_append(pOut, zPath+i, j-i); + } + if( slash && i>0 && zPath[strlen(zPath)-1]=='/'){ + blob_append(pOut, "/", 1); + } + blob_reset(&tmp); + return; + } + if( zPwd[i]==0 && zPath[i]=='/' ){ + memcpy(&tmp, pOut, sizeof(tmp)); + blob_set(pOut, "./"); + blob_append(pOut, &zPath[i+1], -1); + blob_reset(&tmp); + return; + } + while( zPath[i-1]!='/' ){ i--; } + if( zPwd[0]=='/' && strlen(zPwd)==1 ){ + /* If on '/', don't go to higher level */ + blob_zero(&tmp); + }else{ + blob_set(&tmp, "../"); + } + for(j=i; zPwd[j]; j++){ + if( zPwd[j]=='/' ){ + blob_append(&tmp, "../", 3); + } + } + blob_append(&tmp, &zPath[i], -1); + blob_reset(pOut); + memcpy(pOut, &tmp, sizeof(tmp)); + } +} + +/* +** COMMAND: test-relative-name +** +** Test the operation of the relative name generator. +*/ +void cmd_test_relative_name(void){ + int i; + Blob x; + int slashFlag = find_option("slash",0,0)!=0; + blob_zero(&x); + for(i=2; i<g.argc; i++){ + file_relative_name(g.argv[i], &x, slashFlag); + fossil_print("%s\n", blob_buffer(&x)); + blob_reset(&x); + } +} + +/* +** Compute a full path name for a file in the local tree. If +** the absolute flag is non-zero, the computed path will be +** absolute, starting with the root path of the local tree; +** otherwise, it will be relative to the root of the local +** tree. In both cases, the root of the local tree is defined +** by the g.zLocalRoot variable. Return TRUE on success. On +** failure, print and error message and quit if the errFatal +** flag is true. If errFatal is false, then simply return 0. +*/ +int file_tree_name( + const char *zOrigName, + Blob *pOut, + int absolute, + int errFatal +){ + Blob localRoot; + int nLocalRoot; + char *zLocalRoot; + Blob full; + int nFull; + char *zFull; + int (*xCmp)(const char*,const char*,int); + + blob_zero(pOut); + if( !g.localOpen ){ + if( absolute && !file_is_absolute_path(zOrigName) ){ + if( errFatal ){ + fossil_fatal("relative to absolute needs open check-out tree: %s", + zOrigName); + } + return 0; + }else{ + /* + ** The original path may be relative or absolute; however, without + ** an open check-out tree, the only things we can do at this point + ** is return it verbatim or generate a fatal error. The caller is + ** probably expecting a tree-relative path name will be returned; + ** however, most places where this function is called already check + ** if the local check-out tree is open, either directly or indirectly, + ** which would make this situation impossible. Alternatively, they + ** could check the returned path using the file_is_absolute_path() + ** function. + */ + blob_appendf(pOut, "%s", zOrigName); + return 1; + } + } + file_canonical_name(g.zLocalRoot, &localRoot, 1); + nLocalRoot = blob_size(&localRoot); + zLocalRoot = blob_buffer(&localRoot); + assert( nLocalRoot>0 && zLocalRoot[nLocalRoot-1]=='/' ); + file_canonical_name(zOrigName, &full, 0); + nFull = blob_size(&full); + zFull = blob_buffer(&full); + if( filenames_are_case_sensitive() ){ + xCmp = fossil_strncmp; + }else{ + xCmp = fossil_strnicmp; + } + + /* Special case. zOrigName refers to g.zLocalRoot directory. */ + if( (nFull==nLocalRoot-1 && xCmp(zLocalRoot, zFull, nFull)==0) + || (nFull==1 && zFull[0]=='/' && nLocalRoot==1 && zLocalRoot[0]=='/') ){ + if( absolute ){ + blob_append(pOut, zLocalRoot, nLocalRoot); + }else{ + blob_append(pOut, ".", 1); + } + blob_reset(&localRoot); + blob_reset(&full); + return 1; + } + + if( nFull<=nLocalRoot || xCmp(zLocalRoot, zFull, nLocalRoot) ){ + blob_reset(&localRoot); + blob_reset(&full); + if( errFatal ){ + fossil_fatal("file outside of check-out tree: %s", zOrigName); + } + return 0; + } + if( absolute ){ + if( !file_is_absolute_path(zOrigName) ){ + blob_append(pOut, zLocalRoot, nLocalRoot); + } + blob_append(pOut, zOrigName, -1); + blob_resize(pOut, file_simplify_name(blob_buffer(pOut), + blob_size(pOut), 0)); + }else{ + blob_append(pOut, &zFull[nLocalRoot], nFull-nLocalRoot); + } + blob_reset(&localRoot); + blob_reset(&full); + return 1; +} + +/* +** COMMAND: test-tree-name +** +** Test the operation of the tree name generator. +** +** Options: +** --absolute Return an absolute path instead of a relative one +** --case-sensitive B Enable or disable case-sensitive filenames. B is +** a boolean: "yes", "no", "true", "false", etc. +*/ +void cmd_test_tree_name(void){ + int i; + Blob x; + int absoluteFlag = find_option("absolute",0,0)!=0; + db_find_and_open_repository(0,0); + blob_zero(&x); + for(i=2; i<g.argc; i++){ + if( file_tree_name(g.argv[i], &x, absoluteFlag, 1) ){ + fossil_print("%s\n", blob_buffer(&x)); + blob_reset(&x); + } + } +} + +/* +** zFile is the name of a file. Return true if that file is in the +** current working directory (the "pwd" or file_getcwd() directory). +** Return false if the file is someplace else. +*/ +int file_in_cwd(const char *zFile){ + char *zFull = file_canonical_name_dup(zFile); + char *zCwd = file_getcwd(0,0); + size_t nCwd = strlen(zCwd); + size_t nFull = strlen(zFull); + int rc = 1; + int (*xCmp)(const char*,const char*,int); + + if( filenames_are_case_sensitive() ){ + xCmp = fossil_strncmp; + }else{ + xCmp = fossil_strnicmp; + } + + if( nFull>nCwd+1 + && xCmp(zFull,zCwd,nCwd)==0 + && zFull[nCwd]=='/' + && strchr(zFull+nCwd+1, '/')==0 + ){ + rc = 1; + }else{ + rc = 0; + } + fossil_free(zFull); + fossil_free(zCwd); + return rc; +} + +/* +** Parse a URI into scheme, host, port, and path. +*/ +void file_parse_uri( + const char *zUri, + Blob *pScheme, + Blob *pHost, + int *pPort, + Blob *pPath +){ + int i, j; + + for(i=0; zUri[i] && zUri[i]>='a' && zUri[i]<='z'; i++){} + if( zUri[i]!=':' ){ + blob_zero(pScheme); + blob_zero(pHost); + blob_set(pPath, zUri); + return; + } + blob_init(pScheme, zUri, i); + i++; + if( zUri[i]=='/' && zUri[i+1]=='/' ){ + i += 2; + j = i; + while( zUri[i] && zUri[i]!='/' && zUri[i]!=':' ){ i++; } + blob_init(pHost, &zUri[j], i-j); + if( zUri[i]==':' ){ + i++; + *pPort = atoi(&zUri[i]); + while( zUri[i] && zUri[i]!='/' ){ i++; } + } + }else{ + blob_zero(pHost); + } + if( zUri[i]=='/' ){ + blob_set(pPath, &zUri[i]); + }else{ + blob_set(pPath, "/"); + } +} + +/* +** Construct a random temporary filename into pBuf where the name of +** the temporary file is derived from zBasis. The suffix on the temp +** file is the same as the suffix on zBasis, and the temp file has +** the root of zBasis in its name. +** +** If zTag is not NULL, then try to create the temp-file using zTag +** as a differentiator. If that fails, or if zTag is NULL, then use +** a bunch of random characters as the tag. +** +** Dangerous characters in zBasis are changed. +** +** See also fossil_temp_filename() and file_time_tempname(); +*/ +void file_tempname(Blob *pBuf, const char *zBasis, const char *zTag){ +#if defined(_WIN32) + const char *azDirs[] = { + 0, /* GetTempPath */ + 0, /* TEMP */ + 0, /* TMP */ + ".", + }; +#else + static const char *azDirs[] = { + 0, /* TMPDIR */ + "/var/tmp", + "/usr/tmp", + "/tmp", + "/temp", + ".", + }; +#endif + static const unsigned char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + unsigned int i; + const char *zDir = "."; + int cnt = 0; + char zRand[16]; + int nBasis; + const char *zSuffix; + char *z; + +#if defined(_WIN32) + wchar_t zTmpPath[MAX_PATH]; + + if( GetTempPathW(MAX_PATH, zTmpPath) ){ + azDirs[0] = fossil_path_to_utf8(zTmpPath); + /* Removing trailing \ from the temp path */ + z = (char*)azDirs[0]; + i = (int)strlen(z)-1; + if( i>0 && z[i]=='\\' ) z[i] = 0; + } + + azDirs[1] = fossil_getenv("TEMP"); + azDirs[2] = fossil_getenv("TMP"); +#else + azDirs[0] = fossil_getenv("TMPDIR"); +#endif + + for(i=0; i<count(azDirs); i++){ + if( azDirs[i]==0 ) continue; + if( !file_isdir(azDirs[i], ExtFILE) ) continue; + zDir = azDirs[i]; + break; + } + + assert( zBasis!=0 ); + zSuffix = 0; + for(i=0; zBasis[i]; i++){ + if( zBasis[i]=='/' || zBasis[i]=='\\' ){ + zBasis += i+1; + i = -1; + }else if( zBasis[i]=='.' ){ + zSuffix = zBasis + i; + } + } + if( zSuffix==0 || zSuffix<=zBasis ){ + zSuffix = ""; + nBasis = i; + }else{ + nBasis = (int)(zSuffix - zBasis); + } + if( nBasis==0 ){ + nBasis = 6; + zBasis = "fossil"; + } + do{ + blob_zero(pBuf); + if( cnt++>20 ) fossil_fatal("cannot generate a temporary filename"); + if( zTag==0 ){ + const int nRand = sizeof(zRand)-1; + sqlite3_randomness(nRand, zRand); + for(i=0; i<nRand; i++){ + zRand[i] = (char)zChars[ ((unsigned char)zRand[i])%(sizeof(zChars)-1) ]; + } + zRand[nRand] = 0; + zTag = zRand; + } + blob_appendf(pBuf, "%s/%.*s~%s%s", zDir, nBasis, zBasis, zTag, zSuffix); + zTag = 0; + for(z=blob_str(pBuf); z!=0 && (z=strpbrk(z,"'\"`;|$&"))!=0; z++){ + z[0] = '_'; + } + }while( file_size(blob_str(pBuf), ExtFILE)>=0 ); + +#if defined(_WIN32) + fossil_path_free((char *)azDirs[0]); + fossil_path_free((char *)azDirs[1]); + fossil_path_free((char *)azDirs[2]); + /* Change all \ characters in the windows path into / so that they can + ** be safely passed to a subcommand, such as by gdiff */ + z = blob_buffer(pBuf); + for(i=0; z[i]; i++) if( z[i]=='\\' ) z[i] = '/'; +#else + fossil_path_free((char *)azDirs[0]); +#endif +} + +/* +** Compute a temporary filename in zDir. The filename is based on +** the current time. +** +** See also fossil_temp_filename() and file_tempname(); +*/ +char *file_time_tempname(const char *zDir, const char *zSuffix){ + struct tm *tm; + unsigned int r; + static unsigned int cnt = 0; + time_t t; + t = time(0); + tm = gmtime(&t); + sqlite3_randomness(sizeof(r), &r); + return mprintf("%s/%04d%02d%02d%02d%02d%02d%04d%06d%s", + zDir, tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, + tm->tm_hour, tm->tm_min, tm->tm_sec, cnt++, r%1000000, zSuffix); +} + + +/* +** COMMAND: test-tempname +** Usage: fossil test-name [--time SUFFIX] [--tag NAME] BASENAME ... +** +** Generate temporary filenames derived from BASENAME. Use the --time +** option to generate temp names based on the time of day. If --tag NAME +** is specified, try to use NAME as the differentiator in the temp file. +** +** If --time is used, file_time_tempname() generates the filename. +** If BASENAME is present, file_tempname() generates the filename. +** Without --time or BASENAME, fossil_temp_filename() generates the filename. +*/ +void file_test_tempname(void){ + int i; + const char *zSuffix = find_option("time",0,1); + Blob x = BLOB_INITIALIZER; + char *z; + const char *zTag = find_option("tag",0,1); + verify_all_options(); + if( g.argc<=2 ){ + z = fossil_temp_filename(); + fossil_print("%s\n", z); + sqlite3_free(z); + } + for(i=2; i<g.argc; i++){ + if( zSuffix ){ + z = file_time_tempname(g.argv[i], zSuffix); + fossil_print("%s\n", z); + fossil_free(z); + }else{ + file_tempname(&x, g.argv[i], zTag); + fossil_print("%s\n", blob_str(&x)); + blob_reset(&x); + } + } +} + + +/* +** Return true if a file named zName exists and has identical content +** to the blob pContent. If zName does not exist or if the content is +** different in any way, then return false. +** +** This routine assumes RepoFILE +*/ +int file_is_the_same(Blob *pContent, const char *zName){ + i64 iSize; + int rc; + Blob onDisk; + + iSize = file_size(zName, RepoFILE); + if( iSize<0 ) return 0; + if( iSize!=blob_size(pContent) ) return 0; + blob_read_from_file(&onDisk, zName, RepoFILE); + rc = blob_compare(&onDisk, pContent); + blob_reset(&onDisk); + return rc==0; +} + +/* +** Return the value of an environment variable as UTF8. +** Use fossil_path_free() to release resources. +*/ +char *fossil_getenv(const char *zName){ +#ifdef _WIN32 + wchar_t *uName = fossil_utf8_to_unicode(zName); + void *zValue = _wgetenv(uName); + fossil_unicode_free(uName); +#else + char *zValue = getenv(zName); +#endif + if( zValue ) zValue = fossil_path_to_utf8(zValue); + return zValue; +} + +/* +** Sets the value of an environment variable as UTF8. +*/ +int fossil_setenv(const char *zName, const char *zValue){ + int rc; + char *zString = mprintf("%s=%s", zName, zValue); +#ifdef _WIN32 + wchar_t *uString = fossil_utf8_to_unicode(zString); + rc = _wputenv(uString); + fossil_unicode_free(uString); + fossil_free(zString); +#else + rc = putenv(zString); + /* NOTE: Cannot free the string on POSIX. */ + /* fossil_free(zString); */ +#endif + return rc; +} + +/* +** Clear all environment variables +*/ +int fossil_clearenv(void){ +#ifdef _WIN32 + int rc = 0; + LPWCH zzEnv = GetEnvironmentStringsW(); + if( zzEnv ){ + LPCWSTR zEnv = zzEnv; /* read-only */ + while( 1 ){ + LPWSTR zNewEnv = _wcsdup(zEnv); /* writable */ + if( zNewEnv ){ + LPWSTR zEquals = wcsstr(zNewEnv, L"="); + if( zEquals ){ + zEquals[1] = 0; /* no value */ + if( zNewEnv==zEquals || _wputenv(zNewEnv)==0 ){ /* via CRT */ + /* do nothing */ + }else{ + zEquals[0] = 0; /* name only */ + if( !SetEnvironmentVariableW(zNewEnv, NULL) ){ /* via Win32 */ + rc = 1; + } + } + if( rc==0 ){ + zEnv += (lstrlenW(zEnv) + 1); /* double NUL term? */ + if( zEnv[0]==0 ){ + free(zNewEnv); + break; /* no more vars */ + } + } + }else{ + rc = 1; + } + }else{ + rc = 1; + } + free(zNewEnv); + if( rc!=0 ) break; + } + if( !FreeEnvironmentStringsW(zzEnv) ){ + rc = 2; + } + }else{ + rc = 1; + } + return rc; +#else + extern char **environ; + environ[0] = 0; + return 0; +#endif +} + +/* +** Like fopen() but always takes a UTF8 argument. +** +** This function assumes ExtFILE. In other words, symbolic links +** are always followed. +*/ +FILE *fossil_fopen(const char *zName, const char *zMode){ +#ifdef _WIN32 + wchar_t *uMode = fossil_utf8_to_unicode(zMode); + wchar_t *uName = fossil_utf8_to_path(zName, 0); + FILE *f = _wfopen(uName, uMode); + fossil_path_free(uName); + fossil_unicode_free(uMode); +#else + FILE *f = fopen(zName, zMode); +#endif + return f; +} + +/* +** Wrapper for freopen() that understands UTF8 arguments. +*/ +FILE *fossil_freopen(const char *zName, const char *zMode, FILE *stream){ +#ifdef _WIN32 + wchar_t *uMode = fossil_utf8_to_unicode(zMode); + wchar_t *uName = fossil_utf8_to_path(zName, 0); + FILE *f = _wfreopen(uName, uMode, stream); + fossil_path_free(uName); + fossil_unicode_free(uMode); +#else + FILE *f = freopen(zName, zMode, stream); +#endif + return f; +} + +/* +** Works like fclose() except that: +** +** 1) is a no-op if f is 0 or if it is stdin. +** +** 2) If f is one of (stdout, stderr), it is flushed but not closed. +*/ +void fossil_fclose(FILE *f){ + if(f!=0){ + if(stdout==f || stderr==f){ + fflush(f); + }else if(stdin!=f){ + fclose(f); + } + } +} + +/* +** Works like fopen(zName,"wb") except that: +** +** 1) If zName is "-", the stdout handle is returned. +** +** 2) Else file_mkfolder() is used to create all directories +** which lead up to the file before opening it. +** +** 3) It fails fatally if the file cannot be opened. +*/ +FILE *fossil_fopen_for_output(const char *zFilename){ + if(zFilename[0]=='-' && zFilename[1]==0){ + return stdout; + }else{ + FILE * p; + file_mkfolder(zFilename, ExtFILE, 1, 0); + p = fossil_fopen(zFilename, "wb"); + if( p==0 ){ +#if defined(_WIN32) + const char *zReserved = file_is_win_reserved(zFilename); + if( zReserved ){ + fossil_fatal("cannot open \"%s\" because \"%s\" is " + "a reserved name on Windows", zFilename, + zReserved); + } +#endif + fossil_fatal("unable to open file \"%s\" for writing", + zFilename); + } + return p; + } +} + + +/* +** Return non-NULL if zFilename contains pathname elements that +** are reserved on Windows. The returned string is the disallowed +** path element. +*/ +const char *file_is_win_reserved(const char *zPath){ + static const char *const azRes[] = { "CON","PRN","AUX","NUL","COM","LPT" }; + static char zReturn[5]; + int i; + while( zPath[0] ){ + for(i=0; i<count(azRes); i++){ + if( sqlite3_strnicmp(zPath, azRes[i], 3)==0 + && ((i>=4 && fossil_isdigit(zPath[3]) + && (zPath[4]=='/' || zPath[4]=='.' || zPath[4]==0)) + || (i<4 && (zPath[3]=='/' || zPath[3]=='.' || zPath[3]==0))) + ){ + sqlite3_snprintf(5,zReturn,"%.*s", i>=4 ? 4 : 3, zPath); + return zReturn; + } + } + while( zPath[0] && zPath[0]!='/' ) zPath++; + while( zPath[0]=='/' ) zPath++; + } + return 0; +} + +/* +** COMMAND: test-valid-for-windows +** Usage: fossil test-valid-for-windows FILENAME .... +** +** Show which filenames are not valid for Windows +*/ +void file_test_valid_for_windows(void){ + int i; + for(i=2; i<g.argc; i++){ + fossil_print("%s %s\n", file_is_win_reserved(g.argv[i]), g.argv[i]); + } +} + +/* +** Returns non-zero if the specified file extension belongs to a Fossil +** repository file. +*/ +int file_is_repository_extension(const char *zPath){ + if( fossil_strcmp(zPath, ".fossil")==0 ) return 1; +#if USE_SEE + if( fossil_strcmp(zPath, ".efossil")==0 ) return 1; +#endif + return 0; +} + +/* +** Returns non-zero if the specified path appears to match a file extension +** that should belong to a Fossil repository file. +*/ +int file_contains_repository_extension(const char *zPath){ + if( sqlite3_strglob("*.fossil*",zPath)==0 ) return 1; +#if USE_SEE + if( sqlite3_strglob("*.efossil*",zPath)==0 ) return 1; +#endif + return 0; +} + +/* +** Returns non-zero if the specified path ends with a file extension that +** should belong to a Fossil repository file. +*/ +int file_ends_with_repository_extension(const char *zPath, int bQual){ + if( bQual ){ + if( sqlite3_strglob("*/*.fossil", zPath)==0 ) return 1; +#if USE_SEE + if( sqlite3_strglob("*/*.efossil", zPath)==0 ) return 1; +#endif + }else{ + if( sqlite3_strglob("*.fossil", zPath)==0 ) return 1; +#if USE_SEE + if( sqlite3_strglob("*.efossil", zPath)==0 ) return 1; +#endif + } + return 0; +} + +/* +** Remove surplus "/" characters from the beginning of a full pathname. +** Extra leading "/" characters are benign on unix. But on Windows +** machines, they must be removed. Example: Convert "/C:/fossil/xyx.fossil" +** into "C:/fossil/xyz.fossil". Cygwin should behave as Windows here. +*/ +const char *file_cleanup_fullpath(const char *z){ +#if defined(_WIN32) || defined(__CYGWIN__) + if( z[0]=='/' && fossil_isalpha(z[1]) && z[2]==':' && z[3]=='/' ) z++; +#else + while( z[0]=='/' && z[1]=='/' ) z++; +#endif + return z; +} + +/* +** Find the name of all objects (files and subdirectories) in a given +** directory that match a GLOB pattern. If zGlob is NULL, then return +** all objects. The list is written into *pazList and the number of +** entries is returned. If pazList is NULL, then only the count is +** returned. +** +** If zDir is not a directory, *pazList is unchanged and -1 is returned. +** +** Memory used to old *pazList should be freed using a subsequent call +** to file_directory_list_free(). +** +** This routine never counts the two "." and ".." special directory +** entries, even if the provided glob would match them. +*/ +int file_directory_list( + const char *zDir, /* Directory to get a listing of */ + const char *zGlob, /* Only list objects matching this pattern */ + int omitDotFiles, /* 0: skip "." and "..", 1: no .-files, 2: keep all */ + int nLimit, /* Find at most this many files. 0 means "all" */ + char ***pazList /* OUT: Write the list here, if not NULL */ +){ + void *zNative; + DIR *d; + int n = -1; + int nAlloc = 0; + if( pazList ) *pazList = 0; + zNative = fossil_utf8_to_path(zDir,1); + d = opendir(zNative); + if( d ){ + struct dirent *pEntry; + n = 0; + while( (pEntry=readdir(d))!=0 ){ + char *zUtf8 = 0; + if( pEntry->d_name[0]==0 ) continue; + if( pEntry->d_name[0]=='.' + && omitDotFiles<2 + && (omitDotFiles==1 + /* Skip the special "." and ".." entries unless omitDotFiles>=2 */ + || pEntry->d_name[1]==0 + || (pEntry->d_name[1]=='.' && pEntry->d_name[2]==0) + ) + ){ + continue; + } + if( zGlob ){ + int rc; + zUtf8 = fossil_path_to_utf8(pEntry->d_name); + rc = sqlite3_strglob(zGlob, zUtf8); + if( rc ){ + fossil_path_free(zUtf8); + continue; + } + } + if( pazList ){ + if( n+1 >= nAlloc ){ + nAlloc = 100 + n; + *pazList = fossil_realloc(*pazList, nAlloc*sizeof(char*)); + } + if( zUtf8==0 ){ + zUtf8 = fossil_path_to_utf8(pEntry->d_name); + } + (*pazList)[n] = fossil_strdup(zUtf8); + } + n++; + if( zUtf8 ) fossil_path_free(zUtf8); + if( nLimit>0 && n>=nLimit ) break; + } + closedir(d); + } + fossil_path_free(zNative); + if( pazList ) (*pazList)[n] = 0; + return n; +} +void file_directory_list_free(char **azList){ + char **az; + if( azList==0 ) return; + az = azList; + while( az[0] ){ + fossil_free(az[0]); + az++; + } + fossil_free(azList); +} + +/* +** COMMAND: test-dir-list +** +** Usage: %fossil test-dir-list NAME [GLOB] [OPTIONS] +** +** Return the names of up to N objects in the directory NAME. If GLOB is +** provided, then only show objects that match the GLOB pattern. +** +** This command is intended for testing the file_directory_list() function. +** +** Options: +** +** --count Only count files, do not list them. +** --limit N Only show the first N files seen +** --nodots Do not show or count files that start with '.' +*/ +void test_dir_list_cmd(void){ + int omitDotFiles = find_option("nodots",0,0)!=0; + const char *zLimit = find_option("limit",0,1); + int countOnly = find_option("count",0,0)!=0; + const char *zGlob; + const char *zDir; + char **azList = 0; + int nList; + + verify_all_options(); + if( g.argc!=3 && g.argc!=4 ){ + usage("NAME [GLOB] [-nodots]"); + } + zDir = g.argv[2]; + zGlob = g.argc==4 ? g.argv[3] : 0; + nList = file_directory_list(zDir, zGlob, omitDotFiles, + zLimit ? atoi(zLimit) : 0, + countOnly ? 0 : &azList); + if( countOnly ){ + fossil_print("%d\n", nList); + }else{ + int i; + for(i=0; i<nList; i++){ + fossil_print(" %s\n", azList[i]); + } + } + file_directory_list_free(azList); +} + +/* +** Internal helper for touch_cmd(). zAbsName must be resolvable as-is +** to an existing file - this function does not expand/normalize +** it. i.e. it "really should" be an absolute path. zTreeName is +** strictly cosmetic: it is used when dryRunFlag, verboseFlag, or +** quietFlag generate output, and is assumed to be a repo-relative or +** or subdir-relative filename. +** +** newMTime is the file's new timestamp (Unix epoch). +** +** Returns 1 if it sets zAbsName's mtime, 0 if it does not (indicating +** that the file already has that timestamp or a warning was emitted +** or was not found). If dryRunFlag is true then it outputs the name +** of the file it would have timestamped but does not stamp the +** file. If verboseFlag is true, it outputs a message if the file's +** timestamp is actually modified. If quietFlag is true then the +** output of non-fatal warning messages is suppressed. +** +** As a special case, if newMTime is 0 then this function emits a +** warning (unless quietFlag is true), does NOT set the timestamp, and +** returns 0. The timestamp is known to be zero when +** mtime_of_manifest_file() is asked to provide the timestamp for a +** file which is currently undergoing an uncommitted merge (though +** this may depend on exactly where that merge is happening the +** history of the project). +*/ +static int touch_cmd_stamp_one_file(char const *zAbsName, + char const *zTreeName, + i64 newMtime, int dryRunFlag, + int verboseFlag, int quietFlag){ + i64 currentMtime; + if(newMtime==0){ + if( quietFlag==0 ){ + fossil_print("SKIPPING timestamp of 0: %s\n", zTreeName); + } + return 0; + } + currentMtime = file_mtime(zAbsName, 0); + if(currentMtime<0){ + fossil_print("SKIPPING: cannot stat file: %s\n", zAbsName); + return 0; + }else if(currentMtime==newMtime){ + return 0; + }else if( dryRunFlag!=0 ){ + fossil_print( "dry-run: %s\n", zTreeName ); + }else{ + file_set_mtime(zAbsName, newMtime); + if( verboseFlag!=0 ){ + fossil_print( "touched %s\n", zTreeName ); + } + } + return 1; +} + +/* +** Internal helper for touch_cmd(). If the given file name is found in +** the given check-out version, which MUST be the check-out version +** currently populating the vfile table, the vfile.mrid value for the +** file is returned, else 0 is returned. zName must be resolvable +** as-is from the vfile table - this function neither expands nor +** normalizes it, though it does compare using the repo's +** filename_collation() preference. +*/ +static int touch_cmd_vfile_mrid( int vid, char const *zName ){ + int mrid = 0; + static Stmt q = empty_Stmt_m; + db_static_prepare(&q, + "SELECT vfile.mrid " + "FROM vfile LEFT JOIN blob ON vfile.mrid=blob.rid " + "WHERE vid=:vid AND pathname=:pathname %s", + filename_collation()); + db_bind_int(&q, ":vid", vid); + db_bind_text(&q, ":pathname", zName); + if(SQLITE_ROW==db_step(&q)){ + mrid = db_column_int(&q, 0); + } + db_reset(&q); + return mrid; +} + +/* +** COMMAND: touch* +** +** Usage: %fossil touch ?OPTIONS? ?FILENAME...? +** +** For each file in the current check-out matching one of the provided +** list of glob patterns and/or file names, the file's mtime is +** updated to a value specified by one of the flags --checkout, +** --checkin, or --now. +** +** If neither glob patterns nor filenames are provided, it operates on +** all files managed by the currently checked-out version. +** +** This command gets its name from the conventional Unix "touch" +** command. +** +** Options: +** --now Stamp each affected file with the current time. +** This is the default behavior. +** -c|--checkin Stamp each affected file with the time of the +** most recent check-in which modified that file +** -C|--checkout Stamp each affected file with the time of the +** currently checked-out version +** -g GLOBLIST Comma-separated list of glob patterns +** -G GLOBFILE Similar to -g but reads its globs from a +** fossil-conventional glob list file +** -v|--verbose Outputs extra information about its globs +** and each file it touches +** -n|--dry-run Outputs which files would require touching, +** but does not touch them +** -q|--quiet Suppress warnings, e.g. when skipping unmanaged +** or out-of-tree files +** +** Only one of --now, --checkin, and --checkout may be used. The +** default is --now. +** +** Only one of -g or -G may be used. If neither is provided and no +** additional filenames are provided, the effect is as if a glob of +** '*' were provided, i.e. all files belonging to the +** currently checked-out version. Note that all glob patterns provided +** via these flags are always evaluated as if they are relative to the +** top of the source tree, not the current working (sub)directory. +** Filenames provided without these flags, on the other hand, are +** treated as relative to the current directory. +** +** As a special case, files currently undergoing an uncommitted merge +** might not get timestamped with --checkin because it may be +** impossible for fossil to choose between multiple potential +** timestamps. A non-fatal warning is emitted for such cases. +** +*/ +void touch_cmd(){ + const char * zGlobList; /* -g List of glob patterns */ + const char * zGlobFile; /* -G File of glob patterns */ + Glob * pGlob = 0; /* List of glob patterns */ + int verboseFlag; + int dryRunFlag; + int vid; /* Check-out version */ + int changeCount = 0; /* Number of files touched */ + int quietFlag = 0; /* -q|--quiet */ + int timeFlag; /* -1==--checkin, 1==--checkout, 0==--now */ + i64 nowTime = 0; /* Timestamp of --now or --checkout */ + Stmt q; + Blob absBuffer = empty_blob; /* Absolute filename buffer */ + + verboseFlag = find_option("verbose","v",0)!=0; + quietFlag = g.fQuiet; + dryRunFlag = find_option("dry-run","n",0)!=0; + zGlobList = find_option("glob", "g",1); + zGlobFile = find_option("globfile", "G",1); + + if(zGlobList && zGlobFile){ + fossil_fatal("Options -g and -G may not be used together."); + } + + { + int const ci = + (find_option("checkin","c",0) || find_option("check-in",0,0)) + ? 1 : 0; + int const co = find_option("checkout","C",0) ? 1 : 0; + int const now = find_option("now",0,0) ? 1 : 0; + if(ci + co + now > 1){ + fossil_fatal("Options --checkin, --checkout, and --now may " + "not be used together."); + }else if(co){ + timeFlag = 1; + if(verboseFlag){ + fossil_print("Timestamp = current check-out version.\n"); + } + }else if(ci){ + timeFlag = -1; + if(verboseFlag){ + fossil_print("Timestamp = check-in in which each file was " + "most recently modified.\n"); + } + }else{ + timeFlag = 0; + if(verboseFlag){ + fossil_print("Timestamp = current system time.\n"); + } + } + } + + verify_all_options(); + + db_must_be_within_tree(); + vid = db_lget_int("checkout", 0); + if(vid==0){ + fossil_fatal("Cannot determine check-out version."); + } + + if(zGlobList){ + pGlob = *zGlobList ? glob_create(zGlobList) : 0; + }else if(zGlobFile){ + Blob globs = empty_blob; + blob_read_from_file(&globs, zGlobFile, ExtFILE); + pGlob = glob_create( globs.aData ); + blob_reset(&globs); + } + if( pGlob && verboseFlag!=0 ){ + int i; + for(i=0; i<pGlob->nPattern; ++i){ + fossil_print("glob: %s\n", pGlob->azPattern[i]); + } + } + + db_begin_transaction(); + if(timeFlag==0){/*--now*/ + nowTime = time(0); + }else if(timeFlag>0){/*--checkout: get the check-out + manifest's timestamp*/ + assert(vid>0); + nowTime = db_int64(-1, + "SELECT CAST(strftime('%%s'," + "(SELECT mtime FROM event WHERE objid=%d)" + ") AS INTEGER)", vid); + if(nowTime<0){ + fossil_fatal("Could not determine check-out version's time!"); + } + }else{ /* --checkin */ + assert(0 == nowTime); + } + if((pGlob && pGlob->nPattern>0) || g.argc<3){ + /* + ** We have either (1) globs or (2) no trailing filenames. If there + ** are neither globs nor filenames then we operate on all managed + ** files. + */ + db_prepare(&q, + "SELECT vfile.mrid, pathname " + "FROM vfile LEFT JOIN blob ON vfile.mrid=blob.rid " + "WHERE vid=%d", vid); + while(SQLITE_ROW==db_step(&q)){ + int const fid = db_column_int(&q, 0); + const char * zName = db_column_text(&q, 1); + i64 newMtime = nowTime; + char const * zAbs = 0; /* absolute path */ + absBuffer.nUsed = 0; + assert(timeFlag<0 ? newMtime==0 : newMtime>0); + if(pGlob){ + if(glob_match(pGlob, zName)==0) continue; + } + blob_appendf( &absBuffer, "%s%s", g.zLocalRoot, zName ); + zAbs = blob_str(&absBuffer); + if( newMtime || mtime_of_manifest_file(vid, fid, &newMtime)==0 ){ + changeCount += + touch_cmd_stamp_one_file( zAbs, zName, newMtime, dryRunFlag, + verboseFlag, quietFlag ); + } + } + db_finalize(&q); + } + glob_free(pGlob); + pGlob = 0; + if(g.argc>2){ + /* + ** Trailing filenames on the command line. These require extra + ** care to avoid modifying unmanaged or out-of-tree files and + ** finding an associated --checkin timestamp. + */ + int i; + Blob treeNameBuf = empty_blob; /* Buffer for file_tree_name(). */ + for( i = 2; i < g.argc; ++i, + blob_reset(&treeNameBuf) ){ + char const * zArg = g.argv[i]; + char const * zTreeFile; /* repo-relative filename */ + char const * zAbs; /* absolute filename */ + i64 newMtime = nowTime; + int nameCheck; + int fid; /* vfile.mrid of file */ + nameCheck = file_tree_name( zArg, &treeNameBuf, 0, 0 ); + if(nameCheck==0){ + if(quietFlag==0){ + fossil_print("SKIPPING out-of-tree file: %s\n", zArg); + } + continue; + } + zTreeFile = blob_str(&treeNameBuf); + fid = touch_cmd_vfile_mrid( vid, zTreeFile ); + if(fid==0){ + if(quietFlag==0){ + fossil_print("SKIPPING unmanaged file: %s\n", zArg); + } + continue; + } + absBuffer.nUsed = 0; + blob_appendf(&absBuffer, "%s%s", g.zLocalRoot, zTreeFile); + zAbs = blob_str(&absBuffer); + if(timeFlag<0){/*--checkin*/ + if(mtime_of_manifest_file( vid, fid, &newMtime )!=0){ + fossil_fatal("Could not resolve --checkin mtime of %s", zTreeFile); + } + }else{ + assert(newMtime>0); + } + changeCount += + touch_cmd_stamp_one_file( zAbs, zArg, newMtime, dryRunFlag, + verboseFlag, quietFlag ); + } + } + db_end_transaction(0); + blob_reset(&absBuffer); + if( dryRunFlag!=0 ){ + fossil_print("dry-run: would have touched %d file(s)\n", + changeCount); + }else{ + fossil_print("Touched %d file(s)\n", changeCount); + } +} + +/* +** If zFileName is not NULL and contains a '.', this returns a pointer +** to the position after the final '.', else it returns NULL. As a +** special case, if it ends with a period then a pointer to the +** terminating NUL byte is returned. +*/ +const char * file_extension(const char *zFileName){ + const char * zExt = zFileName ? strrchr(zFileName, '.') : 0; + return zExt ? &zExt[1] : 0; +} + +/* +** Returns non-zero if the specified file name ends with any reserved name, +** e.g.: _FOSSIL_ or .fslckout. Specifically, it returns 1 for exact match +** or 2 for a tail match on a longer file name. +** +** For the sake of efficiency, zFilename must be a canonical name, e.g. an +** absolute path using only forward slash ('/') as a directory separator. +** +** nFilename must be the length of zFilename. When negative, strlen() will +** be used to calculate it. +*/ +int file_is_reserved_name(const char *zFilename, int nFilename){ + const char *zEnd; /* one-after-the-end of zFilename */ + int gotSuffix = 0; /* length of suffix (-wal, -shm, -journal) */ + + assert( zFilename && "API misuse" ); + if( nFilename<0 ) nFilename = (int)strlen(zFilename); + if( nFilename<8 ) return 0; /* strlen("_FOSSIL_") */ + zEnd = zFilename + nFilename; + if( nFilename>=12 ){ /* strlen("_FOSSIL_-(shm|wal)") */ + /* Check for (-wal, -shm, -journal) suffixes, with an eye towards + ** runtime speed. */ + if( zEnd[-4]=='-' ){ + if( fossil_strnicmp("wal", &zEnd[-3], 3) + && fossil_strnicmp("shm", &zEnd[-3], 3) ){ + return 0; + } + gotSuffix = 4; + }else if( nFilename>=16 && zEnd[-8]=='-' ){ /*strlen(_FOSSIL_-journal) */ + if( fossil_strnicmp("journal", &zEnd[-7], 7) ) return 0; + gotSuffix = 8; + } + if( gotSuffix ){ + assert( 4==gotSuffix || 8==gotSuffix ); + zEnd -= gotSuffix; + nFilename -= gotSuffix; + gotSuffix = 1; + } + assert( nFilename>=8 && "strlen(_FOSSIL_)" ); + assert( gotSuffix==0 || gotSuffix==1 ); + } + switch( zEnd[-1] ){ + case '_':{ + if( fossil_strnicmp("_FOSSIL_", &zEnd[-8], 8) ) return 0; + if( 8==nFilename ) return 1; + return zEnd[-9]=='/' ? 2 : gotSuffix; + } + case 'T': + case 't':{ + if( nFilename<9 || zEnd[-9]!='.' + || fossil_strnicmp(".fslckout", &zEnd[-9], 9) ){ + return 0; + } + if( 9==nFilename ) return 1; + return zEnd[-10]=='/' ? 2 : gotSuffix; + } + default:{ + return 0; + } + } +} + +/* +** COMMAND: test-is-reserved-name +** +** Usage: %fossil test-is-reserved-name FILENAMES... +** +** Passes each given name to file_is_reserved_name() and outputs one +** line per file: the result value of that function followed by the +** name. +*/ +void test_is_reserved_name_cmd(void){ + int i; + + if(g.argc<3){ + usage("FILENAME_1 [...FILENAME_N]"); + } + for( i = 2; i < g.argc; ++i ){ + const int check = file_is_reserved_name(g.argv[i], -1); + fossil_print("%d %s\n", check, g.argv[i]); + } +} + + +/* +** Returns 1 if the given directory contains a file named .fslckout, 2 +** if it contains a file named _FOSSIL_, else returns 0. +*/ +int dir_has_ckout_db(const char *zDir){ + int rc = 0; + i64 sz; + char * zCkoutDb = mprintf("%//.fslckout", zDir); + if(file_isfile(zCkoutDb, ExtFILE)){ + rc = 1; + }else{ + fossil_free(zCkoutDb); + zCkoutDb = mprintf("%//_FOSSIL_", zDir); + if(file_isfile(zCkoutDb, ExtFILE)){ + rc = 2; + } + } + if( rc && ((sz = file_size(zCkoutDb, ExtFILE))<1024 || (sz%512)!=0) ){ + rc = 0; + } + fossil_free(zCkoutDb); + return rc; +} + +/* +** This is the implementation of inode(FILENAME) SQL function. +** +** dev_inode(FILENAME) returns a string. If FILENAME exists and is +** a regular file, then the return string is of the form: +** +** DEV/INODE +** +** Where DEV and INODE are the device number and inode number for +** the file. On Windows, the volume serial number (DEV) and file +** identifier (INODE) are used to compute the value, see comments +** on the win32_file_id() function. +** +** If FILENAME does not exist, then the return is an empty string. +** +** The value of inode() can be used to eliminate files from a list +** that have duplicates because they have differing names due to links. +** +** Code that wants to use this SQL function needs to first register +** it using a call such as the following: +** +** sqlite3_create_function(g.db, "inode", 1, SQLITE_UTF8, 0, +** file_inode_sql_func, 0, 0); +*/ +void file_inode_sql_func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zFilename; + assert( argc==1 ); + zFilename = (const char*)sqlite3_value_text(argv[0]); + if( zFilename==0 || zFilename[0]==0 || file_access(zFilename,F_OK) ){ + sqlite3_result_text(context, "", 0, SQLITE_STATIC); + return; + } +#if defined(_WIN32) + { + char *zFileId = win32_file_id(zFilename); + if( zFileId ){ + sqlite3_result_text(context, zFileId, -1, fossil_free); + }else{ + sqlite3_result_text(context, "", 0, SQLITE_STATIC); + } + } +#else + { + struct stat buf; + int rc; + memset(&buf, 0, sizeof(buf)); + rc = stat(zFilename, &buf); + if( rc ){ + sqlite3_result_text(context, "", 0, SQLITE_STATIC); + }else{ + sqlite3_result_text(context, + mprintf("%lld/%lld", (i64)buf.st_dev, (i64)buf.st_ino), -1, + fossil_free); + } + } +#endif +} |