Merge master to johnmcpms/signing

.gitignore

@@ -406,3 +406,5 @@ src/msix/common/MSIXResource.cpp
 src/test/MacOS-Linux/testApiResults.txt
 src/test/mobile/iOSBVT/iOSBVT.xcodeproj/project.xcworkspace/
 src/test/mobile/TEST-MsixSDK-AOSP.xml
+
+Thumbs.db

CODEOWNERS

@@ -3,3 +3,9 @@
 
 # MsixCoreInstaller owners
 /MsixCore/ @wcheng-msft @jyvenugo @sarjanas-msft
+
+# Utils library
+/tools/utils/ @ranm-msft @msftrubengu @johnmcpms @lechacon @jamespik
+
+# Azure Pipelines tasks
+/tools/pipelines-tasks @ranm-msft @msftrubengu @johnmcpms @lechacon

MsixCore/msixmgr/CIMProvider.cpp

@@ -0,0 +1,118 @@
+#include "MSIXWindows.hpp"
+#include "CIMProvider.hpp"
+#include "ApplyACLsProvider.hpp"
+#include "msixmgrLogger.hpp"
+#include "..\msixmgrLib\GeneralUtil.hpp"
+#include <string>
+#include <iostream>
+#include <vector>
+#include <TraceLoggingProvider.h>
+#include "InstallUI.hpp"
+
+using namespace MsixCoreLib;
+using namespace std;
+
+namespace MsixCoreLib
+{
+    class CreateCIMDll
+    {
+        public:
+            CreateCIMDll::CreateCIMDll()
+            {
+
+            }
+
+            CreateCIMDll::~CreateCIMDll()
+            {
+                if (module != nullptr)
+                {
+                    FreeLibrary(module);
+                }
+            }
+
+            HRESULT load()
+            {
+                module = LoadLibrary(L"createcim.dll");
+                if (module == nullptr)
+                {
+                    std::wcout << std::endl;
+                    std::wcout << "Failed to load createcim.dll. Please confirm the dll is next to this exe." << std::endl;
+                    std::wcout << std::endl;
+
+                    return HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND);
+                }
+                return S_OK;
+            }
+
+            HMODULE get()
+            {
+                return module;
+            }
+
+        private:
+            HMODULE module;
+    };
+
+    HRESULT CreateAndAddToCIM(
+        _In_ std::wstring cimPath,
+        _In_ std::wstring sourcePath,
+        _In_ std::wstring rootDirectory)
+    {
+        CreateCIMDll createCIM;
+        RETURN_IF_FAILED(createCIM.load());
+
+        typedef HRESULT(STDMETHODCALLTYPE *CREATEANDADDTOCIMFILE)(
+            std::wstring cimFilePath,
+            std::wstring sourceRootPath,
+            std::wstring imageRootPath);
+
+        CREATEANDADDTOCIMFILE CreateAndAddToCimFileFunc =
+            reinterpret_cast<CREATEANDADDTOCIMFILE>
+            (GetProcAddress(createCIM.get(), "CreateAndAddToCIMFile"));
+
+        RETURN_IF_FAILED(CreateAndAddToCimFileFunc(cimPath, sourcePath, rootDirectory));
+
+        return S_OK;
+    }
+
+    HRESULT MountCIM(
+        std::wstring cimFilePath,
+        std::wstring& volumeId)
+    {
+        CreateCIMDll createCIM;
+        RETURN_IF_FAILED(createCIM.load());
+
+        typedef HRESULT(STDMETHODCALLTYPE *MOUNTCIM)(
+            std::wstring cimFilePath,
+            std::wstring& volumeId);
+
+        MOUNTCIM MountCIMFunc =
+            reinterpret_cast<MOUNTCIM>
+            (GetProcAddress(createCIM.get(), "MountCIM"));
+
+        RETURN_IF_FAILED(MountCIMFunc(cimFilePath, volumeId));
+
+        return S_OK;
+    }
+
+    HRESULT UnmountCIM(
+        _In_opt_ std::wstring cimFilePath,
+        _In_opt_ std::wstring volumeIdString)
+    {
+        CreateCIMDll createCIM;
+        RETURN_IF_FAILED(createCIM.load());
+
+        typedef HRESULT(STDMETHODCALLTYPE *UNMOUNTCIM)(
+            std::wstring cimFilePath,
+            std::wstring volumeIdString);
+
+        UNMOUNTCIM UnmountCIMFunc =
+            reinterpret_cast<UNMOUNTCIM>
+            (GetProcAddress(createCIM.get(), "UnmountCIM"));
+
+        RETURN_IF_FAILED(UnmountCIMFunc(cimFilePath, volumeIdString));
+
+        return S_OK;
+    }
+
+}

MsixCore/msixmgr/CIMProvider.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <string>
+
+namespace MsixCoreLib
+{
+    HRESULT CreateAndAddToCIM(
+        _In_ std::wstring cimPath,
+        _In_ std::wstring sourcePath,
+        _In_ std::wstring rootDirectory);
+
+    HRESULT MountCIM(
+        _In_ std::wstring cimFilePath,
+        _Out_ std::wstring& volumeId);
+
+    HRESULT UnmountCIM(
+        _In_opt_ std::wstring cimFilePath,
+        _In_opt_ std::wstring volumeIdString);
+}
+
+
+

MsixCore/msixmgr/CommandLineInterface.cpp

@@ -127,6 +127,71 @@ std::map<std::wstring, Options, CaseInsensitiveLess> CommandLineInterface::s_opt
                     commandLineInterface->m_validateSignature = true;
                     return S_OK;
                 }),
+            },
+            {
+                L"-create",
+                Option(false, IDS_STRING_HELP_OPTION_UNPACK_CREATE,
+                    [&](CommandLineInterface* commandLineInterface, const std::string&)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::Unpack)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->m_create = true;
+                    return S_OK;
+                }),
+            },
+            {
+                L"-rootDirectory",
+                Option(true, IDS_STRING_HELP_OPTION_UNPACK_ROOTDIRECTORY,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& rootDirectory)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::Unpack)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->m_rootDirectory = utf8_to_utf16(rootDirectory);
+                    return S_OK;
+                }),
+            },
+            {
+                L"-fileType",
+                Option(true, IDS_STRING_HELP_OPTION_UNPACK_FILETYPE,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& fileType)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::Unpack)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->SetWVDFileType(utf8_to_utf16(fileType));
+
+                    return S_OK;
+                }),
+            },
+            {
+                L"-vhdSize",
+                Option(true, IDS_STRING_HELP_OPTION_UNPACK_VHDSIZE,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& vhdSize)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::Unpack)
+                    {
+                        return E_INVALIDARG;
+                    }
+
+                    ULONGLONG maxVhdSizeMB = 2040000ull; // MAX SIZE: 2040 GB --> 2040000 MB
+                    errno = 0;
+                    ULONGLONG vhdSizeUll = strtoull(vhdSize.c_str(), NULL, 10 /*base*/);
+                    if ((vhdSizeUll == ULLONG_MAX && errno == ERANGE) ||
+                        vhdSizeUll > maxVhdSizeMB ||
+                        vhdSizeUll < 5ull)
+                    {
+                        std::wcout << "\nInvalid VHD size. Specified value must be at least 5 MB and at most 2040000 MB\n" << std::endl;
+                        return E_INVALIDARG;
+                    }
+
+                    commandLineInterface->m_vhdSize = vhdSizeUll;
+                    return S_OK;
+                }),
             }
         })
     },
@@ -158,6 +223,125 @@ std::map<std::wstring, Options, CaseInsensitiveLess> CommandLineInterface::s_opt
             }
         })
     },
+    {
+        L"-MountImage",
+        Options(false, IDS_STRING_HELP_OPTION_MOUNTIMAGE,
+        [&](CommandLineInterface* commandLineInterface, const std::string&)
+        {
+            if (commandLineInterface->m_operationType != OperationType::Undefined)
+            {
+                return E_INVALIDARG;
+            }
+            commandLineInterface->m_operationType = OperationType::MountImage;
+            return S_OK;
+        },
+        {
+            {
+                L"-imagePath",
+                Option(true, IDS_STRING_HELP_OPTION_MOUNTIMAGE_IMAGEPATH,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& imagePath)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::MountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->m_mountImagePath = utf8_to_utf16(imagePath);
+                    return S_OK;
+                }),
+            },
+            {
+                L"-fileType",
+                Option(true, IDS_STRING_HELP_OPTION_MOUNT_FILETYPE,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& fileType)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::MountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->SetWVDFileType(utf8_to_utf16(fileType));
+                    return S_OK;
+                }),
+            },
+            {
+                L"-readOnly",
+                Option(true, IDS_STRING_HELP_OPTION_MOUNT_READONLY,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& readOnly)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::MountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    if (CaseInsensitiveEquals(utf8_to_utf16(readOnly), std::wstring(L"true")))
+                    {
+                        commandLineInterface->m_readOnly = true;
+                    }
+                    else if (CaseInsensitiveEquals(utf8_to_utf16(readOnly), std::wstring(L"false")))
+                    {
+                        commandLineInterface->m_readOnly = false;
+                    }
+                    else
+                    {
+                        return E_INVALIDARG;
+                    }
+                    return S_OK;
+                }),
+            }
+        })
+    },
+    {
+        L"-UnmountImage",
+        Options(false, IDS_STRING_HELP_OPTION_UNMOUNTIMAGE,
+        [&](CommandLineInterface* commandLineInterface, const std::string&)
+        {
+            if (commandLineInterface->m_operationType != OperationType::Undefined)
+            {
+                return E_INVALIDARG;
+            }
+            commandLineInterface->m_operationType = OperationType::UnmountImage;
+            return S_OK;
+        },
+        {
+            {
+                L"-imagePath",
+                Option(true, IDS_STRING_HELP_OPTION_MOUNTIMAGE_IMAGEPATH,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& imagePath)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::UnmountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->m_mountImagePath = utf8_to_utf16(imagePath);
+                    return S_OK;
+                }),
+            },
+            {
+                L"-volumeId",
+                Option(true, IDS_STRING_HELP_OPTION_UNMOUNTIMAGE_VOLUMEID,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& volumeId)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::UnmountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->m_volumeId = utf8_to_utf16(volumeId);
+                    return S_OK;
+                }),
+            },
+            {
+                L"-fileType",
+                Option(true, IDS_STRING_HELP_OPTION_MOUNT_FILETYPE,
+                    [&](CommandLineInterface* commandLineInterface, const std::string& fileType)
+                {
+                    if (commandLineInterface->m_operationType != OperationType::UnmountImage)
+                    {
+                        return E_INVALIDARG;
+                    }
+                    commandLineInterface->SetWVDFileType(utf8_to_utf16(fileType));
+                    return S_OK;
+                }),
+            }
+        })
+    },
     {
         L"-?",
         Options(false, IDS_STRING_HELP_OPTION_HELP,
@@ -275,4 +459,24 @@ HRESULT CommandLineInterface::Init()
     }
 
     return S_OK;
+}
+
+void CommandLineInterface::SetWVDFileType(std::wstring fileType)
+{
+    if (CaseInsensitiveEquals(fileType, L"VHD"))
+    {
+        this->m_fileType = WVDFileType::VHD;
+    }
+    else if (CaseInsensitiveEquals(fileType, L"VHDX"))
+    {
+        this->m_fileType = WVDFileType::VHDX;
+    }
+    else if (CaseInsensitiveEquals(fileType, L"CIM"))
+    {
+        this->m_fileType = WVDFileType::CIM;
+    }
+    else
+    {
+        this->m_fileType = WVDFileType::NotSpecified;
+    }
 }