Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/OnefileBootstrap.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* The main program for onefile bootstrap.
  *
  * It needs to unpack the attached files and and then loads and executes
@@ -59,9 +44,7 @@
 #include "stdbool.h"
 #endif
 
-#if defined(_WIN32)
-#include <imagehlp.h>
-#else
+#if !defined(_WIN32)
 #include <dirent.h>
 #include <signal.h>
 #include <sys/stat.h>
@@ -78,16 +61,13 @@
 #define _NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING
 #define _NUITKA_ONEFILE_TEMP_BOOL 0
 #define _NUITKA_ONEFILE_CHILD_GRACE_TIME_INT 5000
-#define _NUITKA_ONEFILE_TEMP_SPEC "%TEMP%/onefile_%PID%_%TIME%"
+#define _NUITKA_ONEFILE_TEMP_SPEC "{TEMP}/onefile_{PID}_{TIME}"
 
-#define _NUITKA_EXPERIMENTAL_DEBUG_AUTO_UPDATE
 #define _NUITKA_AUTO_UPDATE_BOOL 1
+#define _NUITKA_AUTO_UPDATE_DEBUG_BOOL 1
 #define _NUITKA_AUTO_UPDATE_URL_SPEC "https://..."
 
-#if __APPLE__
-#define _NUITKA_PAYLOAD_FROM_MACOS_SECTION
-#endif
-
+#define _NUITKA_ATTACH_CONSOLE_WINDOW 1
 #endif
 
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
@@ -111,15 +91,25 @@
 #include "decompress/zstd_decompress_block.c"
 #endif
 
-// Some handy macro definitions, e.g. unlikely.
+// Some handy macro definitions, e.g. unlikely and NUITKA_MAY_BE_UNUSED
 #include "nuitka/hedley.h"
 #define likely(x) HEDLEY_LIKELY(x)
 #define unlikely(x) HEDLEY_UNLIKELY(x)
+#ifdef __GNUC__
+#define NUITKA_MAY_BE_UNUSED __attribute__((__unused__))
+#else
+#define NUITKA_MAY_BE_UNUSED
+#endif
 
 #include "HelpersChecksumTools.c"
+#include "HelpersEnvironmentVariablesSystem.c"
 #include "HelpersFilesystemPaths.c"
 #include "HelpersSafeStrings.c"
 
+#if defined(_WIN32) && (defined(_NUITKA_ATTACH_CONSOLE_WINDOW) || defined(_NUITKA_HIDE_CONSOLE_WINDOW))
+#include "HelpersConsole.c"
+#endif
+
 // For tracing outputs if enabled at compile time.
 #include "nuitka/tracing.h"
 
@@ -134,39 +124,24 @@ static void fatalIOError(char const *message, error_code_t error_code) {
 }
 
 // Failure to expand the template for where to extract to.
-static void fatalErrorTempFiles(void) { fatalError("Error, couldn't runtime expand target path."); }
+static void fatalErrorTempFiles(void) {
+    fatalIOError("Error, couldn't unpack file to target path.", getLastErrorCode());
+}
 
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
 static void fatalErrorAttachedData(void) { fatalError("Error, couldn't decode attached data."); }
 #endif
 
-static void fatalErrorHeaderAttachedData(void) { fatalError("Error, could find attached data header."); }
-
-// Left over data in attached payload should not happen.
-static void fatalErrorReadAttachedData(void) { fatalError("Error, couldn't read attached data."); }
+static void fatalErrorHeaderAttachedData(void) { fatalError("Error, couldn't find attached data header."); }
 
 // Out of memory error.
+#if !defined(_WIN32) || _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
 static void fatalErrorMemory(void) { fatalError("Error, couldn't allocate memory."); }
+#endif
 
 // Could not launch child process.
 static void fatalErrorChild(char const *message, error_code_t error_code) { fatalIOError(message, error_code); }
 
-#if defined(_WIN32)
-static void appendWCharSafeW(wchar_t *target, wchar_t c, size_t buffer_size) {
-    while (*target != 0) {
-        target++;
-        buffer_size -= 1;
-    }
-
-    if (buffer_size < 1) {
-        abort();
-    }
-
-    *target++ = c;
-    *target = 0;
-}
-#endif
-
 static void fatalErrorTempFileCreate(filename_char_t const *filename) {
     fprintf(stderr, "Error, failed to open '" FILENAME_FORMAT_STR "' for writing.\n", filename);
     exit(2);
@@ -187,45 +162,23 @@ static FILE_HANDLE createFileForWritingChecked(filename_char_t const *filename)
     return result;
 }
 
-static int getMyPid(void) {
-#if defined(_WIN32)
-    return GetCurrentProcessId();
-#else
-    return getpid();
-#endif
-}
-
-static void setEnvironVar(char const *var_name, char const *value) {
-#if defined(_WIN32)
-    SetEnvironmentVariable("NUITKA_ONEFILE_PARENT", value);
-#else
-    setenv(var_name, value, 1);
-#endif
-}
-
 static unsigned char const *payload_data = NULL;
 static unsigned char const *payload_current = NULL;
-static size_t stream_end_pos;
+static unsigned long long payload_size = 0;
 
-#ifdef _NUITKA_PAYLOAD_FROM_MACOS_SECTION
+#ifdef __APPLE__
 
 #include <mach-o/getsect.h>
 #include <mach-o/ldsyms.h>
 
-static unsigned char *findMacOSBinarySection(void) {
+static void initPayloadData(void) {
     const struct mach_header *header = &_mh_execute_header;
 
     unsigned long section_size;
 
-    unsigned char *result = getsectiondata(header, "payload", "payload", &section_size);
-    stream_end_pos = (size_t)section_size;
-
-    return result;
-}
-
-static void initPayloadData(void) {
-    payload_data = findMacOSBinarySection();
+    payload_data = getsectiondata(header, "payload", "payload", &section_size);
     payload_current = payload_data;
+    payload_size = section_size;
 }
 
 static void closePayloadData(void) {}
@@ -233,9 +186,12 @@ static void closePayloadData(void) {}
 #elif defined(_WIN32)
 
 static void initPayloadData(void) {
-    payload_data =
-        (const unsigned char *)LockResource(LoadResource(NULL, FindResource(NULL, MAKEINTRESOURCE(27), RT_RCDATA)));
+    HRSRC windows_resource = FindResource(NULL, MAKEINTRESOURCE(27), RT_RCDATA);
+
+    payload_data = (const unsigned char *)LockResource(LoadResource(NULL, windows_resource));
     payload_current = payload_data;
+
+    payload_size = SizeofResource(NULL, windows_resource);
 }
 
 // Note: it appears unlocking the resource is not actually foreseen.
@@ -296,10 +252,6 @@ static void releaseZSTD(void) {
 
 #endif
 
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-static size_t getPosition(void) { return payload_current - payload_data; }
-#endif
-
 static void readChunk(void *buffer, size_t size) {
     // printf("Reading %d\n", size);
 
@@ -307,21 +259,8 @@ static void readChunk(void *buffer, size_t size) {
     payload_current += size;
 }
 
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-static void const *readChunkPointer(size_t size) {
-    // printf("Reading %d\n", size);
-
-    void const *result = payload_current;
-    payload_current += size;
-
-    return result;
-}
-#endif
-
 static void readPayloadChunk(void *buffer, size_t size) {
-#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
-
-    // bool no_payload = false;
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1 && _NUITKA_ONEFILE_ARCHIVE_BOOL == 0
     bool end_of_buffer = false;
 
     // Loop until finished with asked chunk.
@@ -372,28 +311,7 @@ static void readPayloadChunk(void *buffer, size_t size) {
         if (input.size != input.pos) {
             fatalErrorAttachedData();
         }
-
-        // No input available, make it available from stream respecting end.
-        size_t to_read = ZSTD_DStreamInSize();
-        size_t payload_available = stream_end_pos - getPosition();
-
-        static size_t payload_so_far = 0;
-
-        if (payload_available == 0) {
-            continue;
-        }
-
-        if (to_read > payload_available) {
-            to_read = payload_available;
-        }
-
-        input.src = readChunkPointer(to_read);
-        input.pos = 0;
-        input.size = to_read;
-
-        payload_so_far += to_read;
     }
-
 #else
     readChunk(buffer, size);
 #endif
@@ -424,6 +342,15 @@ static unsigned long long readPayloadSizeValue(void) {
     return result;
 }
 
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1 && _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
+static unsigned long long readArchiveFileSizeValue(void) {
+    unsigned long long result;
+    readPayloadChunk(&result, sizeof(unsigned int));
+
+    return result;
+}
+#endif
+
 static filename_char_t readPayloadFilenameCharacter(void) {
     filename_char_t result;
 
@@ -450,6 +377,74 @@ static filename_char_t *readPayloadFilename(void) {
     return buffer;
 }
 
+static void writeContainedFile(FILE_HANDLE target_file, unsigned long long file_size) {
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1
+
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 0
+    if (target_file != FILE_HANDLE_NULL) {
+        if (writeFileChunk(target_file, payload_current, file_size) == false) {
+            fatalErrorTempFiles();
+        }
+    }
+
+    payload_current += file_size;
+#else
+    if (target_file != FILE_HANDLE_NULL) {
+
+        // Nothing available, make sure to make it available from existing input.
+        while (input.pos < input.size) {
+            // printf("available input %ld %ld\n", input.pos, input.size);
+
+            output.pos = 0;
+            output.size = ZSTD_DStreamOutSize();
+
+            size_t const ret = ZSTD_decompressStream(dest_ctx, &output, &input);
+            if (ZSTD_isError(ret)) {
+                fatalErrorAttachedData();
+            }
+
+            // printf("available output %ld %ld\n", output.pos, output.size);
+
+            if (writeFileChunk(target_file, (char const *)output.dst, output.pos) == false) {
+                fatalErrorTempFiles();
+            }
+
+            // printf("made output %ld %lld\n", output.pos, file_size);
+            file_size -= output.pos;
+            assert(file_size >= 0);
+        }
+
+        assert(file_size == 0);
+    }
+#endif
+#else
+    while (file_size > 0) {
+        static char chunk[32768];
+
+        long chunk_size;
+
+        // Doing min manually, as otherwise the compiler is confused from types.
+        if (file_size <= sizeof(chunk)) {
+            chunk_size = (long)file_size;
+        } else {
+            chunk_size = sizeof(chunk);
+        }
+
+        readPayloadChunk(chunk, chunk_size);
+
+        if (target_file != FILE_HANDLE_NULL) {
+            if (writeFileChunk(target_file, chunk, chunk_size) == false) {
+                fatalErrorTempFiles();
+            }
+        }
+
+        file_size -= chunk_size;
+    }
+
+    assert(file_size == 0);
+#endif
+}
+
 // Zero means, not yet created, created unsuccessfully, terminated already.
 #if defined(_WIN32)
 HANDLE handle_process = 0;
@@ -473,7 +468,7 @@ static bool createDirectory(filename_char_t const *path) {
 #if defined(_WIN32)
     if (created_dir_count == 0) {
         filename_char_t home_path[4096];
-        wchar_t *pattern = L"%HOME%";
+        wchar_t *pattern = L"{HOME}";
 
         bool_res = expandTemplatePathFilename(home_path, pattern, sizeof(payload_path) / sizeof(filename_char_t));
 
@@ -818,6 +813,96 @@ extern bool checkSplashScreen(void);
 #endif
 #endif
 
+#ifdef _WIN32
+
+static bool containsWStringAny(wchar_t const *source, wchar_t const *characters) {
+    while (*characters) {
+        if (wcschr(source, *characters) != NULL) {
+            return true;
+        }
+
+        characters++;
+    }
+
+    return false;
+}
+
+static wchar_t *getCommandLineForChildProcess(void) {
+
+    wchar_t *orig_command_line = GetCommandLineW();
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+    wprintf(L"Command line was '%ls'\n", orig_command_line);
+#endif
+
+    int argc;
+    LPWSTR *argv = CommandLineToArgvW(orig_command_line, &argc);
+    assert(argv != NULL);
+    assert(argc > 0);
+
+    static wchar_t result[32768];
+    result[0] = 0;
+
+    argv[0] = getBinaryPath();
+
+    for (int i = 0; i < argc; i++) {
+        if (i >= 1) {
+            appendWCharSafeW(result, L' ', sizeof(result) / sizeof(wchar_t));
+        }
+
+        bool needs_quote = containsWStringAny(argv[i], L" \t\n\v\"");
+
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+        wprintf(L"Command line arg %d was '%ls' needs quoting %ls\n", i, argv[i], needs_quote ? L"yes" : L"no");
+#endif
+
+        if (needs_quote) {
+            appendWCharSafeW(result, L'"', sizeof(result) / sizeof(wchar_t));
+
+            wchar_t const *current = argv[i];
+
+            for (;;) {
+                int backslash_count = 0;
+
+                while (*current == L'\\') {
+                    current++;
+                    backslash_count += 1;
+                }
+
+                if (*current == 0) {
+                    for (int j = 0; j < backslash_count * 2; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+
+                    break;
+                } else if (*current == L'"') {
+                    for (int j = 0; j < backslash_count * 2 + 1; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+                } else {
+                    for (int j = 0; j < backslash_count; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+                }
+
+                appendWCharSafeW(result, *current, sizeof(result) / sizeof(wchar_t));
+
+                current++;
+            }
+
+            appendWCharSafeW(result, L'"', sizeof(result) / sizeof(wchar_t));
+
+        } else {
+            appendWStringSafeW(result, argv[i], sizeof(result) / sizeof(wchar_t));
+        }
+    }
+
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+    wprintf(L"Command line composed to '%ls'\n", result);
+#endif
+    return result;
+}
+#endif
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     int argc = __argc;
@@ -982,11 +1067,20 @@ int wmain(int argc, wchar_t** argv)
 int startup(int argc, wchar_t **argv) {
 #else
 int wmain(int argc, wchar_t **argv) {
+    #if defined(_NUITKA_HIDE_CONSOLE_WINDOW)
+    hideConsoleIfSpawned();
+    #endif
 #endif
 #else
 int main(int argc, char **argv) {
 #endif
 #endif
+    // Attach to the parent console respecting redirection only, otherwise we cannot
+    // even output traces.
+#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+    inheritAttachedConsole();
+#endif
+
     NUITKA_PRINT_TIMING("ONEFILE: Entered main().");
 
     filename_char_t const *pattern = FILENAME_EMPTY_STR _NUITKA_ONEFILE_TEMP_SPEC;
@@ -1011,7 +1105,7 @@ int main(int argc, char **argv) {
     signal(SIGTERM, ourConsoleCtrlHandler);
 #endif
 
-#ifdef _NUITKA_AUTO_UPDATE_BOOL
+#if _NUITKA_AUTO_UPDATE_BOOL
     checkAutoUpdates();
 #endif
 
@@ -1019,20 +1113,18 @@ int main(int argc, char **argv) {
 
     initPayloadData();
 
-#if !defined(_NUITKA_PAYLOAD_FROM_MACOS_SECTION) && !defined(_WIN32)
+#if !defined(__APPLE__) && !defined(_WIN32)
     const off_t size_end_offset = exe_file_mapped.file_size;
 
     NUITKA_PRINT_TIMING("ONEFILE: Determining payload start position.");
 
-    unsigned long long payload_size;
+    assert(sizeof(payload_size) == sizeof(unsigned long long));
     memcpy(&payload_size, payload_data + size_end_offset - sizeof(payload_size), sizeof(payload_size));
 
     unsigned long long start_pos = size_end_offset - sizeof(payload_size) - payload_size;
 
     payload_current += start_pos;
     payload_data += start_pos;
-
-    stream_end_pos = size_end_offset - sizeof(payload_size) - start_pos;
 #endif
 
     NUITKA_PRINT_TIMING("ONEFILE: Checking header for compression.");
@@ -1044,12 +1136,20 @@ int main(int argc, char **argv) {
         fatalErrorHeaderAttachedData();
     }
 
+    NUITKA_PRINT_TIMING("ONEFILE: Header is OK.");
+
 // The 'X' stands for no compression, 'Y' is compressed, handle that.
 #if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
     if (header[2] != 'Y') {
         fatalErrorHeaderAttachedData();
     }
     initZSTD();
+
+    input.src = payload_current;
+    input.pos = 0;
+    input.size = payload_size;
+
+    assert(payload_size > 0);
 #else
     if (header[2] != 'X') {
         fatalErrorHeaderAttachedData();
@@ -1059,8 +1159,6 @@ int main(int argc, char **argv) {
     static filename_char_t first_filename[1024] = {0};
 
 #if _NUITKA_ONEFILE_SPLASH_SCREEN
-    NUITKA_PRINT_TIMING("ONEFILE: Splash screen.");
-
     initSplashScreen();
 #endif
 
@@ -1134,6 +1232,20 @@ int main(int argc, char **argv) {
         }
 #endif
 
+#if _NUITKA_ONEFILE_ARCHIVE_BOOL == 1
+#if _NUITKA_ONEFILE_COMPRESSION_BOOL == 1
+        uint32_t contained_archive_file_size = readArchiveFileSizeValue();
+
+        input.src = payload_current;
+        input.pos = 0;
+        input.size = contained_archive_file_size;
+
+        output.pos = 0;
+        output.size = 0;
+
+        payload_current += contained_archive_file_size;
+#endif
+#endif
         FILE_HANDLE target_file = FILE_HANDLE_NULL;
 
         if (needs_write) {
@@ -1141,34 +1253,7 @@ int main(int argc, char **argv) {
             target_file = createFileForWritingChecked(target_path);
         }
 
-        while (file_size > 0) {
-            static char chunk[32768];
-
-            long chunk_size;
-
-            // Doing min manually, as otherwise the compiler is confused from types.
-            if (file_size <= sizeof(chunk)) {
-                chunk_size = (long)file_size;
-            } else {
-                chunk_size = sizeof(chunk);
-            }
-
-            // TODO: Does zstd support skipping data as well, such that we
-            // do not have to fully decode.
-            readPayloadChunk(chunk, chunk_size);
-
-            if (target_file != FILE_HANDLE_NULL) {
-                if (writeFileChunk(target_file, chunk, chunk_size) == false) {
-                    fatalErrorTempFiles();
-                }
-            }
-
-            file_size -= chunk_size;
-        }
-
-        if (file_size != 0) {
-            fatalErrorReadAttachedData();
-        }
+        writeContainedFile(target_file, file_size);
 
 #if !defined(_WIN32) && !defined(__MSYS__)
         if ((file_flags & 1) && (target_file != FILE_HANDLE_NULL)) {
@@ -1212,7 +1297,7 @@ int main(int argc, char **argv) {
 
     closePayloadData();
 
-#ifdef _NUITKA_AUTO_UPDATE_BOOL
+#if _NUITKA_AUTO_UPDATE_BOOL
     exe_file_updatable = true;
 #endif
 
@@ -1222,11 +1307,20 @@ int main(int argc, char **argv) {
 
     // Pass our pid by value to the child. If we exit for some reason, re-parenting
     // might change it by the time the child looks at its parent.
-    {
-        char buffer[128];
-        snprintf(buffer, sizeof(buffer), "%d", getMyPid());
-        setEnvironVar("NUITKA_ONEFILE_PARENT", buffer);
-    }
+#if defined(_WIN32)
+    setEnvironmentVariableFromLong("NUITKA_ONEFILE_PARENT", GetCurrentProcessId());
+#else
+    setEnvironmentVariableFromLong("NUITKA_ONEFILE_PARENT", (long)getpid());
+#endif
+
+#if defined(_WIN32)
+    filename_char_t const *binary_filename = getBinaryFilenameWideChars(false);
+#else
+    filename_char_t const *binary_filename = getBinaryFilenameHostEncoded(false);
+#endif
+    setEnvironmentVariable("NUITKA_ONEFILE_BINARY", binary_filename);
+
+    setEnvironmentVariable("NUITKA_ORIGINAL_ARGV0", argv[0]);
 
     NUITKA_PRINT_TIMING("ONEFILE: Preparing forking of slave process.");
 
@@ -1234,16 +1328,20 @@ int main(int argc, char **argv) {
 
     STARTUPINFOW si;
     memset(&si, 0, sizeof(si));
+    si.dwFlags = STARTF_USESTDHANDLES;
+    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+    si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
     si.cb = sizeof(si);
 
     PROCESS_INFORMATION pi;
 
-    bool_res = CreateProcessW(first_filename,        // application name
-                              GetCommandLineW(),     // command line
-                              NULL,                  // process attributes
-                              NULL,                  // thread attributes
-                              FALSE,                 // inherit handles
-                              NORMAL_PRIORITY_CLASS, // creation flags
+    bool_res = CreateProcessW(first_filename,                  // application name
+                              getCommandLineForChildProcess(), // command line
+                              NULL,                            // process attributes
+                              NULL,                            // thread attributes
+                              TRUE,                            // inherit handles
+                              NORMAL_PRIORITY_CLASS,           // creation flags
                               NULL, NULL, &si, &pi);
 
     NUITKA_PRINT_TIMING("ONEFILE: Started slave process.");
@@ -1302,6 +1400,10 @@ int main(int argc, char **argv) {
         exit_code = 2;
     } else if (pid == 0) {
         // Child process
+
+        // Make sure, we use the absolute program path for argv[0]
+        argv[0] = getBinaryPath();
+
         execv(first_filename, argv);
 
         fatalErrorChild("Error, couldn't launch child (exec)", errno);
@@ -1328,3 +1430,18 @@ int main(int argc, char **argv) {
 
     return exit_code;
 }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.