Tcl Source Code

file delete -force [file join dir.dir dirinside.link]
removeFile [file join dir.dir inside.file]
removeDirectory [file join dir.dir dirinside.dir]
removeDirectory dir.dir
test filesystem-1.30 {normalisation of nonexistent user} {
    list [catch {file normalize ~noonewiththisname} err] $err
} {1 {user "noonewiththisname" doesn't exist}}
test filesystem-1.30.1 {normalisation of existing user} -body {
    catch {file normalize ~$::tcl_platform(user)}
} -result {0}
test filesystem-1.30.2 {normalisation of nonexistent user specified as user@domain} -body {
    file normalize ~nonexistentuser@nonexistentdomain
} -returnCodes error -result {user "nonexistentuser@nonexistentdomain" doesn't exist}
test filesystem-1.31 {link normalisation: link near filesystem root} {testsetplatform} {
    testsetplatform unix
    file normalize /foo/../bar
} {/bar}
test filesystem-1.32 {link normalisation: link near filesystem root} {testsetplatform} {
    testsetplatform unix
    file normalize /../bar

char *
TclpGetUserHome(
    const char *name,		/* User name for desired home directory. */
    Tcl_DString *bufferPtr)	/* Uninitialized or free DString filled with
				 * name of user's home directory. */
{
    char *result;

    static NETAPIBUFFERFREEPROC *netApiBufferFreeProc;
    static NETGETDCNAMEPROC *netGetDCNameProc;
    static NETUSERGETINFOPROC *netUserGetInfoProc;
    static GETPROFILESDIRECTORYPROC *getProfilesDirectoryProc;
    static int apistubs = 0;

    result = NULL;
    Tcl_DStringInit(bufferPtr);

    if (!apistubs) {
	HINSTANCE handle;
	TCL_DECLARE_MUTEX(initializeMutex)
	Tcl_MutexLock(&initializeMutex);
	if (!apistubs) {
	    handle = LoadLibraryA("netapi32.dll");






	    if (handle) {
		netApiBufferFreeProc = (NETAPIBUFFERFREEPROC *)
			GetProcAddress(handle, "NetApiBufferFree");
		netGetDCNameProc = (NETGETDCNAMEPROC *)
			GetProcAddress(handle, "NetGetDCName");
		netUserGetInfoProc = (NETUSERGETINFOPROC *)
			GetProcAddress(handle, "NetUserGetInfo");
		Tcl_CreateExitHandler(TclpUnloadFile, handle);
	    }
	    handle = LoadLibraryA("userenv.dll");
	    if (handle) {
		getProfilesDirectoryProc = (GETPROFILESDIRECTORYPROC *)
			GetProcAddress(handle, "GetProfilesDirectoryW");
		Tcl_CreateExitHandler(TclpUnloadFile, handle);
	    }
	    
	    apistubs = -1;
	    if ( (netUserGetInfoProc != NULL) && (netGetDCNameProc != NULL)
	      && (netApiBufferFreeProc != NULL) && (getProfilesDirectoryProc != NULL)
	    ) {
		apistubs = 1;
	    }
	}
	Tcl_MutexUnlock(&initializeMutex);
    }

    if (apistubs == 1) {
	USER_INFO_1 *uiPtr;
	Tcl_DString ds;
	int nameLen, rc;
	char *domain;
	WCHAR *wName, *wHomeDir, *wDomain;
	WCHAR buf[MAX_PATH];

	rc = 0;
	nameLen = -1;
	wDomain = NULL;
	domain = strchr(name, '@');
	if (domain == NULL) {
	    const char *ptr;





	    
	    /* no domain - firstly check it's the current user */
	    if ( (ptr = TclpGetUserName(&ds)) != NULL 
	      && strcasecmp(name, ptr) == 0

	    ) {

		/* try safest and fastest way to get current user home */
		ptr = TclGetEnv("HOME", &ds);
		if (ptr != NULL) {

		    Tcl_JoinPath(1, &ptr, bufferPtr);
		    rc = 1;









		    result = Tcl_DStringValue(bufferPtr);
		}
	    }
	    Tcl_DStringFree(&ds);
	} else {
	    Tcl_DStringInit(&ds);
	    wName = Tcl_UtfToUniCharDString(domain + 1, -1, &ds);
	    rc = (netGetDCNameProc)(NULL, wName, (LPBYTE *) &wDomain);
	    Tcl_DStringFree(&ds);
	    nameLen = domain - name;
	}
	if (rc == 0) {
	    Tcl_DStringInit(&ds);
	    wName = Tcl_UtfToUniCharDString(name, nameLen, &ds);
	    while ((netUserGetInfoProc)(wDomain, wName, 1,
		    (LPBYTE *) &uiPtr) != 0) {
		/* 
		 * user does not exists - if domain was not specified,
		 * try again using current domain.
		 */
		rc = 1;
		if (domain != NULL) break;
		/* get current domain */
		rc = (netGetDCNameProc)(NULL, NULL, (LPBYTE *) &wDomain);
		if (rc != 0) break;
		domain = INT2PTR(-1); /* repeat once */
	    }
	    if (rc == 0) {
		DWORD i, size = MAX_PATH;
		wHomeDir = uiPtr->usri1_home_dir;
		if ((wHomeDir != NULL) && (wHomeDir[0] != L'\0')) {
		    size = lstrlenW(wHomeDir);
		    Tcl_UniCharToUtfDString(wHomeDir, size, bufferPtr);
		} else {
		    /*
		     * User exists but has no home dir. Return
		     * "{GetProfilesDirectory}/<user>".
		     */
		    getProfilesDirectoryProc(buf, &size);
		    Tcl_UniCharToUtfDString(buf, size-1, bufferPtr);
		    Tcl_DStringAppend(bufferPtr, "/", 1);
		    Tcl_DStringAppend(bufferPtr, name, nameLen);
		}
		result = Tcl_DStringValue(bufferPtr);
		/* be sure we returns normalized path */
		for (i = 0; i < size; ++i){
		    if (result[i] == '\\') result[i] = '/';
		}
		(*netApiBufferFreeProc)((void *) uiPtr);
	    }
	    Tcl_DStringFree(&ds);
	}
	if (wDomain != NULL) {
	    (*netApiBufferFreeProc)((void *) wDomain);
	}



    }
    if (result == NULL) {
	/*
	 * Look in the "Password Lists" section of system.ini for the local
	 * user. There are also entries in that section that begin with a "*"
	 * character that are used by Windows for other purposes; ignore user
	 * names beginning with a "*".

{
    Tcl_DStringInit(bufPtr);
    Tcl_DStringSetLength(bufPtr, 2+TCL_INTEGER_SPACE);
    wsprintfA(Tcl_DStringValue(bufPtr), "cp%d", GetACP());
    Tcl_DStringSetLength(bufPtr, strlen(Tcl_DStringValue(bufPtr)));
    return Tcl_DStringValue(bufPtr);
}

const char *
TclpGetUserName(
    Tcl_DString *bufferPtr)	/* Uninitialized or free DString filled with
				 * the name of user. */
{
    Tcl_DStringInit(bufferPtr);

    if (TclGetEnv("USERNAME", bufferPtr) == NULL) {
	WCHAR szUserName[UNLEN+1];
	DWORD cchUserNameLen = UNLEN;

	if (!tclWinProcs->getUserName((LPTSTR)szUserName, &cchUserNameLen)) {
	    return NULL;
	}
	cchUserNameLen--;
	if (tclWinProcs->useWide) cchUserNameLen *= sizeof(WCHAR);
	Tcl_WinTCharToUtf((LPTSTR)szUserName, cchUserNameLen, bufferPtr);
    }
    return Tcl_DStringValue(bufferPtr);
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpSetVariables --
 *
 *	Performs platform-specific interpreter initialization related to the

    union {
	SYSTEM_INFO info;
	OemId oemId;
    } sys;
    static OSVERSIONINFOW osInfo;
    static int osInfoInitialized = 0;
    Tcl_DString ds;



    Tcl_SetVar2Ex(interp, "tclDefaultLibrary", NULL,
	    TclGetProcessGlobalValue(&defaultLibraryDir), TCL_GLOBAL_ONLY);

    if (!osInfoInitialized) {
	HMODULE handle = GetModuleHandle(TEXT("NTDLL"));
	int(__stdcall *getversion)(void *) =

    /*
     * Initialize the user name from the environment first, since this is much
     * faster than asking the system.
     * Note: cchUserNameLen is number of characters including nul terminator.
     */

    ptr = TclpGetUserName(&ds);







    Tcl_SetVar2(interp, "tcl_platform", "user", ptr ? ptr : "",
	    TCL_GLOBAL_ONLY);
    Tcl_DStringFree(&ds);
}

/*
 *----------------------------------------------------------------------
 *

#if defined(TCL_THREADS) && defined(USE_THREAD_ALLOC)
MODULE_SCOPE void	TclWinFreeAllocCache(void);
MODULE_SCOPE void	TclFreeAllocCache(void *);
MODULE_SCOPE Tcl_Mutex *TclpNewAllocMutex(void);
MODULE_SCOPE void *	TclpGetAllocCache(void);
MODULE_SCOPE void	TclpSetAllocCache(void *);
#endif /* TCL_THREADS */

MODULE_SCOPE const char*TclpGetUserName(Tcl_DString *bufferPtr);

/* Needed by tclWinFile.c and tclWinFCmd.c */
#ifndef FILE_ATTRIBUTE_REPARSE_POINT
#define FILE_ATTRIBUTE_REPARSE_POINT 0x00000400
#endif

#endif	/* _TCLWININT */