The Tor Browser: python/which/launcher.cpp@b8a032363ba2 (annotated)

python/which/launcher.cpp@b8a032363ba2 (annotated)

python/which/launcher.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
  * Copyright (c) 2002-2003 ActiveState Corp.
  * Author: Trent Mick (TrentM@ActiveState.com)
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 /* Console launch executable.
  *
  * This program exists solely to launch:
  * 		python <installdir>/<exename>.py <argv>
  * on Windows. "<exename>.py" must be in the same directory.
  *
  * Rationale:
  *    - On some Windows flavours .py *can* be put on the PATHEXT to be
  *      able to find "<exename>.py" if it is on the PATH. This is fine
  *      until you need shell redirection to work. It does NOT for
  *      extensions to PATHEXT.  Redirection *does* work for "python
  *      <script>.py" so we will try to do that.
  */
 #ifdef WIN32
     #include <windows.h>
     #include <process.h>
     #include <direct.h>
     #include <shlwapi.h>
 #else /* linux */
     #include <unistd.h>
 #endif /* WIN32 */
 #include <sys/stat.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 //---- constants
 #define BUF_LENGTH 2048
 #define MAX_PYTHON_ARGS 50
 #define MAX_FILES 50
 #define MAXPATHLEN 1024
 #ifdef WIN32
     #define SEP '\\'
     #define ALTSEP '/'
     // path list element separator
     #define DELIM ';'
 #else /* linux */
     #define SEP '/'
     // path list element separator
     #define DELIM ':'
 #endif
 #ifdef WIN32
     #define spawnvp _spawnvp
     #define snprintf _snprintf
     #define vsnprintf _vsnprintf
     //NOTE: this is for the stat *call* and the stat *struct*
     #define stat _stat
 #endif
 //---- globals
 char* programName = NULL;
 char* programPath = NULL;
 #ifndef WIN32 /* i.e. linux */
     extern char **environ;   // the user environment
 #endif /* linux */
 //---- error logging functions
 void _LogError(const char* format ...)
 {
     va_list ap;
     va_start(ap, format);
 #if defined(WIN32) && defined(_WINDOWS)
     // put up a MessageBox
     char caption[BUF_LENGTH+1];
     snprintf(caption, BUF_LENGTH, "Error in %s", programName);
     char msg[BUF_LENGTH+1];
     vsnprintf(msg, BUF_LENGTH, format, ap);
     va_end(ap);
     MessageBox(NULL, msg, caption, MB_OK | MB_ICONEXCLAMATION);
 #else
     fprintf(stderr, "%s: error: ", programName);
     vfprintf(stderr, format, ap);
     va_end(ap);
 #endif /* WIN32 && _WINDOWS */
 }
 void _LogWarning(const char* format ...)
 {
     va_list ap;
     va_start(ap, format);
 #if defined(WIN32) && defined(_WINDOWS)
     // put up a MessageBox
     char caption[BUF_LENGTH+1];
     snprintf(caption, BUF_LENGTH, "Warning in %s", programName);
     char msg[BUF_LENGTH+1];
     vsnprintf(msg, BUF_LENGTH, format, ap);
     va_end(ap);
     MessageBox(NULL, msg, caption, MB_OK | MB_ICONWARNING);
 #else
     fprintf(stderr, "%s: warning: ", programName);
     vfprintf(stderr, format, ap);
     va_end(ap);
 #endif /* WIN32 && _WINDOWS */
 }
 //---- utilities functions
 /* _IsDir: Is the given dirname an existing directory */
 static int _IsDir(char *dirname)
 {
 #ifdef WIN32
     DWORD dwAttrib;
     dwAttrib = GetFileAttributes(dirname);
     if (dwAttrib == -1) {
         return 0;
     }
     if (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) {
         return 1;
     }
     return 0;
 #else /* i.e. linux */
     struct stat buf;
     if (stat(dirname, &buf) != 0)
         return 0;
     if (!S_ISDIR(buf.st_mode))
         return 0;
     return 1;
 #endif
 }
 /* _IsLink: Is the given filename a symbolic link */
 static int _IsLink(char *filename)
 {
 #ifdef WIN32
     return 0;
 #else /* i.e. linux */
     struct stat buf;
     if (lstat(filename, &buf) != 0)
         return 0;
     if (!S_ISLNK(buf.st_mode))
         return 0;
     return 1;
 #endif
 }
 /* Is executable file
  * On Linux: check 'x' permission. On Windows: just check existence.
  */
 static int _IsExecutableFile(char *filename)
 {
 #ifdef WIN32
     return (int)PathFileExists(filename);
 #else /* i.e. linux */
     struct stat buf;
     if (stat(filename, &buf) != 0)
         return 0;
     if (!S_ISREG(buf.st_mode))
         return 0;
     if ((buf.st_mode & 0111) == 0)
         return 0;
     return 1;
 #endif /* WIN32 */
 }
 /* _GetProgramPath: Determine the absolute path to the given program name.
  *
  *      Takes into account the current working directory, etc.
  *      The implementations require the global 'programName' to be set.
  */
 #ifdef WIN32
     static char* _GetProgramPath(void)
     {
         //XXX this is ugly but I didn't want to use malloc, no reason
         static char progPath[MAXPATHLEN+1];
         // get absolute path to module
         if (!GetModuleFileName(NULL, progPath, MAXPATHLEN)) {
             _LogError("could not get absolute program name from "\
                 "GetModuleFileName\n");
             exit(1);
         }
         // just need dirname
         for (char* p = progPath+strlen(progPath);
              *p != SEP && *p != ALTSEP;
              --p)
         {
             *p = '\0';
         }
         *p = '\0';  // remove the trailing SEP as well
         return progPath;
     }
 #else
     /* _JoinPath requires that any buffer argument passed to it has at
        least MAXPATHLEN + 1 bytes allocated.  If this requirement is met,
        it guarantees that it will never overflow the buffer.  If stuff
        is too long, buffer will contain a truncated copy of stuff.
     */
     static void
     _JoinPath(char *buffer, char *stuff)
     {
         size_t n, k;
         if (stuff[0] == SEP)
             n = 0;
         else {
             n = strlen(buffer);
             if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN)
                 buffer[n++] = SEP;
         }
         k = strlen(stuff);
         if (n + k > MAXPATHLEN)
             k = MAXPATHLEN - n;
         strncpy(buffer+n, stuff, k);
         buffer[n+k] = '\0';
     }
     static char*
     _GetProgramPath(void)
     {
         /* XXX this routine does *no* error checking */
         char* path = getenv("PATH");
         static char progPath[MAXPATHLEN+1];
         /* If there is no slash in the argv0 path, then we have to
          * assume the program is on the user's $PATH, since there's no
          * other way to find a directory to start the search from.  If
          * $PATH isn't exported, you lose.
          */
         if (strchr(programName, SEP)) {
             strncpy(progPath, programName, MAXPATHLEN);
         }
         else if (path) {
             int bufspace = MAXPATHLEN;
             while (1) {
                 char *delim = strchr(path, DELIM);
                 if (delim) {
                     size_t len = delim - path;
                     if (len > bufspace) {
                         len = bufspace;
                     }
                     strncpy(progPath, path, len);
                     *(progPath + len) = '\0';
                     bufspace -= len;
                 }
                 else {
                     strncpy(progPath, path, bufspace);
                 }
                 _JoinPath(progPath, programName);
                 if (_IsExecutableFile(progPath)) {
                     break;
                 }
                 if (!delim) {
                     progPath[0] = '\0';
                     break;
                 }
                 path = delim + 1;
             }
         }
         else {
             progPath[0] = '\0';
         }
         // now we have to resolve a string of possible symlinks
         //   - we'll just handle the simple case of a single level of
         //     indirection
         //
         // XXX note this does not handle multiple levels of symlinks
         //     here is pseudo-code for that (please implement it :):
         // while 1:
         //     if islink(progPath):
         //         linkText = readlink(progPath)
         //         if isabsolute(linkText):
         //             progPath = os.path.join(dirname(progPath), linkText)
         //         else:
         //             progPath = linkText
         //     else:
         //         break
         if (_IsLink(progPath)) {
             char newProgPath[MAXPATHLEN+1];
             readlink(progPath, newProgPath, MAXPATHLEN);
             strncpy(progPath, newProgPath, MAXPATHLEN);
         }
         // prefix with the current working directory if the path is
         // relative to conform with the Windows version of this
         if (strlen(progPath) != 0 && progPath[0] != SEP) {
             char cwd[MAXPATHLEN+1];
             char tmp[MAXPATHLEN+1];
             //XXX should check for failure retvals
             getcwd(cwd, MAXPATHLEN);
             snprintf(tmp, MAXPATHLEN, "%s%c%s", cwd, SEP, progPath);
             strncpy(progPath, tmp, MAXPATHLEN);
         }
         // 'progPath' now contains the full path to the program *and* the program
         // name. The latter is not desire.
         char* pLetter = progPath + strlen(progPath);
         for (;pLetter != progPath && *pLetter != SEP; --pLetter) {
             /* do nothing */
         }
         *pLetter = '\0';
         return progPath;
     }
 #endif  /* WIN32 */
 //---- mainline
 int main(int argc, char** argv)
 {
     programName = argv[0];
     programPath = _GetProgramPath();
     // Determine the extension-less program basename.
     // XXX Will not always handle app names with '.' in them (other than
     //     the '.' for the extension.
     char programNameNoExt[MAXPATHLEN+1];
     char *pStart, *pEnd;
     pStart = pEnd = programName + strlen(programName) - 1;
     while (pStart != programName && *(pStart-1) != SEP) {
 	pStart--;
     }
     while (1) {
 	if (pEnd == pStart) {
             pEnd = programName + strlen(programName) - 1;
 	    break;
 	}
 	pEnd--;
 	if (*(pEnd+1) == '.') {
 	    break;
 	}
     }
     strncpy(programNameNoExt, pStart, pEnd-pStart+1);
     *(programNameNoExt+(pEnd-pStart+1)) = '\0';
     // determine the full path to "<exename>.py"
     char pyFile[MAXPATHLEN+1];
     snprintf(pyFile, MAXPATHLEN, "%s%c%s.py", programPath, SEP,
 	     programNameNoExt);
     // Build the argument array for launching.
     char* pythonArgs[MAX_PYTHON_ARGS+1];
     int nPythonArgs = 0;
     pythonArgs[nPythonArgs++] = "python";
     pythonArgs[nPythonArgs++] = "-tt";
     pythonArgs[nPythonArgs++] = pyFile;
     for (int i = 1; i < argc; ++i) {
         pythonArgs[nPythonArgs++] = argv[i];
     }
     pythonArgs[nPythonArgs++] = NULL;
     return _spawnvp(_P_WAIT, pythonArgs[0], pythonArgs);
 }
 //---- mainline for win32 subsystem:windows app
 #ifdef WIN32
     int WINAPI WinMain(
         HINSTANCE hInstance,      /* handle to current instance */
         HINSTANCE hPrevInstance,  /* handle to previous instance */
         LPSTR lpCmdLine,          /* pointer to command line */
         int nCmdShow              /* show state of window */
     )
     {
         return main(__argc, __argv);
     }
 #endif

The Tor Browser / annotate

python/which/launcher.cpp@b8a032363ba2 (annotated)

python/which/launcher.cpp