EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / PyMod-2.7.10 / Modules / getpath.c

/** @file\r
    Return the initial module search path.\r
\r
    This file is based upon the Modules/getpath.c file from the Python distribution\r
    but has had everything not exactly necessary for operation on EDK II stripped\r
    out.\r
\r
    Search in specified locations for the associated Python libraries.\r
\r
    For the EDK II, UEFI, implementation of Python, PREFIX and EXEC_PREFIX\r
    are set as follows:\r
      PREFIX      = /Efi/StdLib\r
      EXEC_PREFIX = PREFIX\r
\r
    The volume is assumed to be the current volume when Python was started.\r
\r
    Py_GetPath returns module_search_path.\r
    Py_GetPrefix returns PREFIX\r
    Py_GetExec_Prefix returns PREFIX\r
    Py_GetProgramFullPath returns the full path to the python executable.\r
\r
    These are built dynamically so that the proper volume name can be prefixed\r
    to the paths.\r
\r
    The following final paths (for Python 2.7.10) are assumed:\r
      /Efi/Tools/Python.efi                     The Python executable.\r
      /Efi/StdLib/lib/python27.10               The version dependent Python modules.\r
      /Efi/StdLib/lib/python.27                 The version independent Python modules.\r
      /Efi/StdLib/lib/python27.10/lib-dynload   Dynamically loadable Python extension modules.\r
\r
    Copyright (c) 2015, Daryl McDaniel. All rights reserved.<BR>\r
    Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>\r
    This program and the accompanying materials are licensed and made available under\r
    the terms and conditions of the BSD License that accompanies this distribution.\r
    The full text of the license may be found at\r
    http://opensource.org/licenses/bsd-license.\r
\r
    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
**/\r
#include <Python.h>\r
#include <osdefs.h>\r
#include  <ctype.h>\r
\r
#define SIFY_I( x ) #x\r
#define SIFY( y )   SIFY_I( y )\r
\r
/* VERSION must be at least two characters long. */\r
#ifndef VERSION\r
  #define VERSION     SIFY(PY_MAJOR_VERSION) SIFY(PY_MINOR_VERSION)\r
#endif\r
\r
#ifndef VPATH\r
  #define VPATH       "."\r
#endif\r
\r
/* Search path entry delimiter */\r
#ifdef DELIM\r
  #define sDELIM        ";"\r
#endif\r
\r
#ifndef PREFIX\r
  #define PREFIX      "/Efi/StdLib"\r
#endif\r
\r
#ifndef EXEC_PREFIX\r
  #define EXEC_PREFIX PREFIX\r
#endif\r
\r
#ifndef   LIBPYTHON\r
  #define   LIBPYTHON     "lib/python" VERSION "." SIFY(PY_MICRO_VERSION)\r
#endif\r
\r
#ifndef PYTHONPATH\r
  #define PYTHONPATH  LIBPYTHON\r
#endif\r
\r
#ifndef LANDMARK\r
  #define LANDMARK    "os.py"\r
#endif\r
\r
#ifdef __cplusplus\r
 extern "C" {\r
#endif\r
\r
static char   prefix[MAXPATHLEN+1];\r
static char   exec_prefix[MAXPATHLEN+1];\r
static char   progpath[MAXPATHLEN+1];\r
static char  *module_search_path          = NULL;\r
static char   lib_python[]                = LIBPYTHON;\r
static char   volume_name[32]             = { 0 };\r
\r
/** Determine if "ch" is a separator character.\r
\r
    @param[in]  ch      The character to test.\r
\r
    @retval     TRUE    ch is a separator character.\r
    @retval     FALSE   ch is NOT a separator character.\r
**/\r
static int\r
is_sep(char ch)\r
{\r
  return ch == SEP || ch == ALTSEP;\r
}\r
\r
/** Reduce a path by its last element.\r
\r
    The last element (everything to the right of the last separator character)\r
    in the path, dir, is removed from the path.  Parameter dir is modified in place.\r
\r
    @param[in,out]    dir   Pointer to the path to modify.\r
**/\r
static void\r
reduce(char *dir)\r
{\r
    size_t i = strlen(dir);\r
    while (i > 0 && !is_sep(dir[i]))\r
        --i;\r
    dir[i] = '\0';\r
}\r
\r
/** Determine if a path is absolute, or not.\r
    An absolute path consists of a volume name, "VOL:", followed by a rooted path,\r
    "/path/elements".  If both of these components are present, the path is absolute.\r
\r
    Let P be a pointer to the path to test.\r
    Let A be a pointer to the first ':' in P.\r
    Let B be a pointer to the first '/' or '\\' in P.\r
\r
    If A and B are not NULL\r
      If (A-P+1) == (B-P) then the path is absolute.\r
    Otherwise, the path is NOT absolute.\r
\r
    @param[in]  path    The path to test.\r
\r
    @retval     -1      Path is absolute but lacking volume name.\r
    @retval      0      Path is NOT absolute.\r
    @retval      1      Path is absolute.\r
*/\r
static int\r
is_absolute(char *path)\r
{\r
  char  *A;\r
  char  *B;\r
\r
  A = strchr(path, ':');\r
  B = strpbrk(path, "/\\");\r
\r
  if(B != NULL) {\r
    if(A == NULL) {\r
      if(B == path) {\r
        return -1;\r
      }\r
    }\r
    else {\r
      if(((A - path) + 1) == (B - path)) {\r
        return 1;\r
      }\r
    }\r
  }\r
  return 0;\r
}\r
\r
\r
/** Add a path component, by appending stuff to buffer.\r
    buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a\r
    NUL-terminated string with no more than MAXPATHLEN characters (not counting\r
    the trailing NUL).  It's a fatal error if it contains a string longer than\r
    that (callers must be careful!).  If these requirements are met, it's\r
    guaranteed that buffer will still be a NUL-terminated string with no more\r
    than MAXPATHLEN characters at exit.  If stuff is too long, only as much of\r
    stuff as fits will be appended.\r
\r
    @param[in,out]    buffer    The path to be extended.\r
    @param[in]        stuff     The stuff to join onto the path.\r
*/\r
static void\r
joinpath(char *buffer, char *stuff)\r
{\r
  size_t n, k;\r
\r
  k = 0;\r
  if (is_absolute(stuff) == 1) {\r
    n = 0;\r
  }\r
  else {\r
    n = strlen(buffer);\r
    if(n == 0) {\r
      strncpy(buffer, volume_name, MAXPATHLEN);\r
      n = strlen(buffer);\r
    }\r
    /* We must not use an else clause here because we want to test n again.\r
        volume_name may have been empty.\r
    */\r
    if (n > 0 && n < MAXPATHLEN) {\r
      if(!is_sep(buffer[n-1])) {\r
        buffer[n++] = SEP;\r
      }\r
      if(is_sep(stuff[0]))   ++stuff;\r
    }\r
  }\r
  if (n > MAXPATHLEN)\r
    Py_FatalError("buffer overflow in getpath.c's joinpath()");\r
  k = strlen(stuff);\r
  if (n + k > MAXPATHLEN)\r
    k = MAXPATHLEN - n;\r
  strncpy(buffer+n, stuff, k);\r
  buffer[n+k] = '\0';\r
}\r
\r
/** Is filename an executable file?\r
\r
    An executable file:\r
      1) exists\r
      2) is a file, not a directory\r
      3) has a name ending with ".efi"\r
      4) Only has a single '.' in the name.\r
\r
    If basename(filename) does not contain a '.', append ".efi" to filename\r
    If filename ends in ".efi", it is executable, else it isn't.\r
\r
    This routine is used to when searching for the file named by argv[0].\r
    As such, there is no need to search for extensions other than ".efi".\r
\r
    @param[in]    filename      The name of the file to test.  It may, or may not, have an extension.\r
\r
    @retval       0     filename already has a path other than ".efi", or it doesn't exist, or is a directory.\r
    @retval       1     filename refers to an executable file.\r
**/\r
static int\r
isxfile(char *filename)\r
{\r
    struct stat  buf;\r
    char        *bn;\r
    char        *newbn;\r
    int          bnlen;\r
\r
    bn = basename(filename);            // Separate off the file name component\r
    reduce(filename);                   // and isolate the path component\r
    bnlen = strlen(bn);\r
    newbn = strrchr(bn, '.');           // Does basename contain a period?\r
    if(newbn == NULL) {                   // Does NOT contain a period.\r
      newbn = &bn[bnlen];\r
      strncpyX(newbn, ".efi", MAXPATHLEN - bnlen);    // append ".efi" to basename\r
      bnlen += 4;\r
    }\r
    else if(strcmp(newbn, ".efi") != 0) {\r
      return 0;                         // File can not be executable.\r
    }\r
    joinpath(filename, bn);             // Stitch path and file name back together\r
\r
    if (stat(filename, &buf) != 0) {    // Now, verify that file exists\r
      return 0;\r
    }\r
    if(S_ISDIR(buf.st_mode)) {          // And it is not a directory.\r
      return 0;\r
    }\r
\r
    return 1;\r
}\r
\r
/** Copy p into path, ensuring that the result is an absolute path.\r
\r
    copy_absolute requires that path be allocated at least\r
    MAXPATHLEN + 1 bytes and that p be no more than MAXPATHLEN bytes.\r
\r
    @param[out]     path    Destination to receive the absolute path.\r
    @param[in]      p       Path to be tested and possibly converted.\r
**/\r
static void\r
copy_absolute(char *path, char *p)\r
{\r
  if (is_absolute(p) == 1)\r
        strcpy(path, p);\r
  else {\r
    if (!getcwd(path, MAXPATHLEN)) {\r
      /* unable to get the current directory */\r
      if(volume_name[0] != 0) {\r
        strcpy(path, volume_name);\r
        joinpath(path, p);\r
      }\r
      else\r
        strcpy(path, p);\r
      return;\r
    }\r
    if (p[0] == '.' && is_sep(p[1]))\r
        p += 2;\r
    joinpath(path, p);\r
  }\r
}\r
\r
/** Modify path so that the result is an absolute path.\r
    absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes.\r
\r
    @param[in,out]    path    The path to be made absolute.\r
*/\r
static void\r
absolutize(char *path)\r
{\r
    char buffer[MAXPATHLEN + 1];\r
\r
    if (is_absolute(path) == 1)\r
        return;\r
    copy_absolute(buffer, path);\r
    strcpy(path, buffer);\r
}\r
\r
/** Extract the volume name from a path.\r
\r
    @param[out]   Dest    Pointer to location in which to store the extracted volume name.\r
    @param[in]    path    Pointer to the path to extract the volume name from.\r
**/\r
static void\r
set_volume(char *Dest, char *path)\r
{\r
  size_t    VolLen;\r
\r
  if(is_absolute(path)) {\r
    VolLen = strcspn(path, "/\\:");\r
    if((VolLen != 0) && (path[VolLen] == ':')) {\r
      (void) strncpyX(Dest, path, VolLen + 1);\r
    }\r
  }\r
}\r
\r
\r
/** Determine paths.\r
\r
    Two directories must be found, the platform independent directory\r
    (prefix), containing the common .py and .pyc files, and the platform\r
    dependent directory (exec_prefix), containing the shared library\r
    modules.  Note that prefix and exec_prefix are the same directory\r
    for UEFI installations.\r
\r
    Separate searches are carried out for prefix and exec_prefix.\r
    Each search tries a number of different locations until a ``landmark''\r
    file or directory is found.  If no prefix or exec_prefix is found, a\r
    warning message is issued and the preprocessor defined PREFIX and\r
    EXEC_PREFIX are used (even though they may not work); python carries on\r
    as best as is possible, but some imports may fail.\r
\r
    Before any searches are done, the location of the executable is\r
    determined.  If argv[0] has one or more slashes in it, it is used\r
    unchanged.  Otherwise, it must have been invoked from the shell's path,\r
    so we search %PATH% for the named executable and use that.  If the\r
    executable was not found on %PATH% (or there was no %PATH% environment\r
    variable), the original argv[0] string is used.\r
\r
    Finally, argv0_path is set to the directory containing the executable\r
    (i.e. the last component is stripped).\r
\r
    With argv0_path in hand, we perform a number of steps.  The same steps\r
    are performed for prefix and for exec_prefix, but with a different\r
    landmark.\r
\r
    The prefix landmark will always be lib/python.VERSION/os.py and the\r
    exec_prefix will always be lib/python.VERSION/dynaload, where VERSION\r
    is Python's version number as defined at the beginning of this file.\r
\r
    First. See if the %PYTHONHOME% environment variable points to the\r
    installed location of the Python libraries.  If %PYTHONHOME% is set, then\r
    it points to prefix and exec_prefix.  %PYTHONHOME% can be a single\r
    directory, which is used for both, or the prefix and exec_prefix\r
    directories separated by the DELIM character.\r
\r
    Next. Search the directories pointed to by the preprocessor variables\r
    PREFIX and EXEC_PREFIX.  These paths are prefixed with the volume name\r
    extracted from argv0_path.  The volume names correspond to the UEFI\r
    shell "map" names.\r
\r
    That's it!\r
\r
    Well, almost.  Once we have determined prefix and exec_prefix, the\r
    preprocessor variable PYTHONPATH is used to construct a path.  Each\r
    relative path on PYTHONPATH is prefixed with prefix.  Then the directory\r
    containing the shared library modules is appended.  The environment\r
    variable $PYTHONPATH is inserted in front of it all.  Finally, the\r
    prefix and exec_prefix globals are tweaked so they reflect the values\r
    expected by other code, by stripping the "lib/python$VERSION/..." stuff\r
    off.  This seems to make more sense given that currently the only\r
    known use of sys.prefix and sys.exec_prefix is for the ILU installation\r
    process to find the installed Python tree.\r
\r
    The final, fully resolved, paths should look something like:\r
      fs0:/Efi/Tools/python.efi\r
      fs0:/Efi/StdLib/lib/python27\r
      fs0:/Efi/StdLib/lib/python27/dynaload\r
\r
**/\r
static void\r
calculate_path(void)\r
{\r
    extern char *Py_GetProgramName(void);\r
\r
    static char delimiter[2] = {DELIM, '\0'};\r
    static char separator[2] = {SEP, '\0'};\r
    char *pythonpath = PYTHONPATH;\r
    char *rtpypath = Py_GETENV("PYTHONPATH");\r
    //char *home = Py_GetPythonHome();\r
    char *path = getenv("path");\r
    char *prog = Py_GetProgramName();\r
    char argv0_path[MAXPATHLEN+1];\r
    char zip_path[MAXPATHLEN+1];\r
    char *buf;\r
    size_t bufsz;\r
    size_t prefixsz;\r
    char *defpath;\r
\r
\r
/* ###########################################################################\r
      Determine path to the Python.efi binary.\r
      Produces progpath, argv0_path, and volume_name.\r
########################################################################### */\r
\r
    /* If there is no slash in the argv0 path, then we have to\r
     * assume python is on the user's $PATH, since there's no\r
     * other way to find a directory to start the search from.  If\r
     * $PATH isn't exported, you lose.\r
     */\r
    if (strchr(prog, SEP))\r
            strncpy(progpath, prog, MAXPATHLEN);\r
    else if (path) {\r
      while (1) {\r
        char *delim = strchr(path, DELIM);\r
\r
        if (delim) {\r
                size_t len = delim - path;\r
                if (len > MAXPATHLEN)\r
                        len = MAXPATHLEN;\r
                strncpy(progpath, path, len);\r
                *(progpath + len) = '\0';\r
        }\r
        else\r
                strncpy(progpath, path, MAXPATHLEN);\r
\r
        joinpath(progpath, prog);\r
        if (isxfile(progpath))\r
                break;\r
\r
        if (!delim) {\r
                progpath[0] = '\0';\r
                break;\r
        }\r
        path = delim + 1;\r
      }\r
    }\r
    else\r
            progpath[0] = '\0';\r
    if ( (!is_absolute(progpath)) && (progpath[0] != '\0') )\r
            absolutize(progpath);\r
    strncpy(argv0_path, progpath, MAXPATHLEN);\r
    argv0_path[MAXPATHLEN] = '\0';\r
    set_volume(volume_name, argv0_path);\r
\r
    reduce(argv0_path);\r
    /* At this point, argv0_path is guaranteed to be less than\r
       MAXPATHLEN bytes long.\r
    */\r
\r
/* ###########################################################################\r
      Build the FULL prefix string, including volume name.\r
      This is the full path to the platform independent libraries.\r
########################################################################### */\r
\r
    strncpy(prefix, volume_name, MAXPATHLEN);\r
    joinpath(prefix, PREFIX);\r
    joinpath(prefix, lib_python);\r
\r
/* ###########################################################################\r
      Build the FULL path to the zipped-up Python library.\r
########################################################################### */\r
\r
    strncpy(zip_path, prefix, MAXPATHLEN);\r
    zip_path[MAXPATHLEN] = '\0';\r
    reduce(zip_path);\r
    joinpath(zip_path, "python00.zip");\r
    bufsz = strlen(zip_path);   /* Replace "00" with version */\r
    zip_path[bufsz - 6] = VERSION[0];\r
    zip_path[bufsz - 5] = VERSION[1];\r
\r
/* ###########################################################################\r
      Build the FULL path to dynamically loadable libraries.\r
########################################################################### */\r
\r
    strncpy(exec_prefix, volume_name, MAXPATHLEN);    // "fs0:"\r
    joinpath(exec_prefix, EXEC_PREFIX);               // "fs0:/Efi/StdLib"\r
    joinpath(exec_prefix, lib_python);                // "fs0:/Efi/StdLib/lib/python.27"\r
    joinpath(exec_prefix, "lib-dynload");             // "fs0:/Efi/StdLib/lib/python.27/lib-dynload"\r
\r
/* ###########################################################################\r
      Build the module search path.\r
########################################################################### */\r
\r
    /* Reduce prefix and exec_prefix to their essence,\r
     * e.g. /usr/local/lib/python1.5 is reduced to /usr/local.\r
     * If we're loading relative to the build directory,\r
     * return the compiled-in defaults instead.\r
     */\r
    reduce(prefix);\r
    reduce(prefix);\r
    /* The prefix is the root directory, but reduce() chopped\r
     * off the "/". */\r
    if (!prefix[0]) {\r
      strcpy(prefix, volume_name);\r
    }\r
    bufsz = strlen(prefix);\r
    if(prefix[bufsz-1] == ':') {    // if prefix consists solely of a volume_name\r
      prefix[bufsz] = SEP;          //    then append SEP indicating the root directory\r
      prefix[bufsz+1] = 0;          //    and ensure the new string is terminated\r
    }\r
\r
    /* Calculate size of return buffer.\r
     */\r
    defpath = pythonpath;\r
    bufsz = 0;\r
\r
    if (rtpypath)\r
        bufsz += strlen(rtpypath) + 1;\r
\r
    prefixsz = strlen(prefix) + 1;\r
\r
    while (1) {\r
        char *delim = strchr(defpath, DELIM);\r
\r
        if (is_absolute(defpath) == 0)\r
            /* Paths are relative to prefix */\r
            bufsz += prefixsz;\r
\r
        if (delim)\r
            bufsz += delim - defpath + 1;\r
        else {\r
            bufsz += strlen(defpath) + 1;\r
            break;\r
        }\r
        defpath = delim + 1;\r
    }\r
\r
    bufsz += strlen(zip_path) + 1;\r
    bufsz += strlen(exec_prefix) + 1;\r
\r
    /* This is the only malloc call in this file */\r
    buf = (char *)PyMem_Malloc(bufsz);\r
\r
    if (buf == NULL) {\r
        /* We can't exit, so print a warning and limp along */\r
        fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");\r
        fprintf(stderr, "Using default static PYTHONPATH.\n");\r
        module_search_path = PYTHONPATH;\r
    }\r
    else {\r
        /* Run-time value of $PYTHONPATH goes first */\r
        if (rtpypath) {\r
            strcpy(buf, rtpypath);\r
            strcat(buf, delimiter);\r
        }\r
        else\r
            buf[0] = '\0';\r
\r
        /* Next is the default zip path */\r
        strcat(buf, zip_path);\r
        strcat(buf, delimiter);\r
\r
        /* Next goes merge of compile-time $PYTHONPATH with\r
         * dynamically located prefix.\r
         */\r
        defpath = pythonpath;\r
        while (1) {\r
            char *delim = strchr(defpath, DELIM);\r
\r
            if (is_absolute(defpath) != 1) {\r
                strcat(buf, prefix);\r
                strcat(buf, separator);\r
            }\r
\r
            if (delim) {\r
                size_t len = delim - defpath + 1;\r
                size_t end = strlen(buf) + len;\r
                strncat(buf, defpath, len);\r
                *(buf + end) = '\0';\r
            }\r
            else {\r
                strcat(buf, defpath);\r
                break;\r
            }\r
            defpath = delim + 1;\r
        }\r
        strcat(buf, delimiter);\r
\r
        /* Finally, on goes the directory for dynamic-load modules */\r
        strcat(buf, exec_prefix);\r
\r
        /* And publish the results */\r
        module_search_path = buf;\r
    }\r
        /*  At this point, exec_prefix is set to VOL:/Efi/StdLib/lib/python.27/dynalib.\r
            We want to get back to the root value, so we have to remove the final three\r
            segments to get VOL:/Efi/StdLib.  Because we don't know what VOL is, and\r
            EXEC_PREFIX is also indeterminate, we just remove the three final segments.\r
        */\r
        reduce(exec_prefix);\r
        reduce(exec_prefix);\r
        reduce(exec_prefix);\r
        if (!exec_prefix[0]) {\r
          strcpy(exec_prefix, volume_name);\r
        }\r
        bufsz = strlen(exec_prefix);\r
        if(exec_prefix[bufsz-1] == ':') {\r
          exec_prefix[bufsz] = SEP;\r
          exec_prefix[bufsz+1] = 0;\r
        }\r
    if (Py_VerboseFlag) PySys_WriteStderr("%s[%d]: module_search_path = \"%s\"\n", __func__, __LINE__, module_search_path);\r
    if (Py_VerboseFlag) PySys_WriteStderr("%s[%d]: prefix             = \"%s\"\n", __func__, __LINE__, prefix);\r
    if (Py_VerboseFlag) PySys_WriteStderr("%s[%d]: exec_prefix        = \"%s\"\n", __func__, __LINE__, exec_prefix);\r
    if (Py_VerboseFlag) PySys_WriteStderr("%s[%d]: progpath           = \"%s\"\n", __func__, __LINE__, progpath);\r
}\r
\r
\r
/* External interface */\r
\r
char *\r
Py_GetPath(void)\r
{\r
    if (!module_search_path)\r
        calculate_path();\r
    return module_search_path;\r
}\r
\r
char *\r
Py_GetPrefix(void)\r
{\r
    if (!module_search_path)\r
        calculate_path();\r
    return prefix;\r
}\r
\r
char *\r
Py_GetExecPrefix(void)\r
{\r
    if (!module_search_path)\r
        calculate_path();\r
    return exec_prefix;\r
}\r
\r
char *\r
Py_GetProgramFullPath(void)\r
{\r
    if (!module_search_path)\r
        calculate_path();\r
    return progpath;\r
}\r
\r
\r
#ifdef __cplusplus\r
}\r
#endif\r
\r