| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #undef UNICODE |
| #undef _UNICODE |
| |
| #define _WIN32_WINDOWS 0x0410 |
| |
| #ifdef _MSC_VER |
| #pragma warning(push, 1) /* disable warnings within system headers */ |
| #define WIN32_LEAN_AND_MEAN |
| #endif |
| #include <windows.h> |
| #include <msiquery.h> |
| #include <shellapi.h> |
| #ifdef _MSC_VER |
| #pragma warning(pop) |
| #endif |
| |
| #include <malloc.h> |
| #include <assert.h> |
| #include <string.h> |
| |
| #ifdef UNICODE |
| #define _UNICODE |
| #define _tstring wstring |
| #else |
| #define _tstring string |
| #endif |
| #include <tchar.h> |
| #include <string> |
| |
| /** creates a temporary folder with a unique name. |
| |
| The returned string is a file URL. |
| */ |
| // static std::_tstring createTempFolder() |
| // { |
| // BOOL bExist = FALSE; |
| // TCHAR szTempName[MAX_PATH]; |
| // do |
| // { |
| // bExist = FALSE; |
| // // Get the temp path. |
| // TCHAR lpPathBuffer[MAX_PATH]; |
| // DWORD dwRetVal = GetTempPath(MAX_PATH, lpPathBuffer); |
| // if (dwRetVal > MAX_PATH || (dwRetVal == 0)) |
| // { |
| // //fprintf (stderr, "GetTempPath failed with error %d.\n", GetLastError()); |
| // return TEXT(""); |
| // } |
| // // Create a temporary file. |
| // UINT uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files |
| // "upg", // temp file name prefix |
| // 0, // create unique name |
| // szTempName); // buffer for name |
| // if (uRetVal == 0) |
| // { |
| // //fprintf (stderr, "GetTempFileName failed with error %d.\n", GetLastError()); |
| // return TEXT(""); |
| // } |
| // //Delete the file |
| // BOOL bDel = DeleteFile(szTempName); |
| // if (FALSE == bDel) |
| // { |
| // //fprintf(stderr, "Could not delete temp file. Error %d.\n", GetLastError()); |
| // return TEXT(""); |
| // } |
| // // Create the directory |
| // BOOL bDir = CreateDirectory(szTempName, NULL); |
| // if (FALSE == bDir) |
| // { |
| // DWORD error =GetLastError(); |
| // if (ERROR_ALREADY_EXISTS == error) |
| // { |
| // bExist = TRUE; |
| // } |
| // else |
| // { |
| // //fprintf(stderr, "CreateDirectory failed with error %d.\n", error); |
| // return TEXT(""); |
| // } |
| // } |
| // } while(bExist); |
| |
| // std::_tstring cur(szTempName); |
| // //make a file URL from the path |
| // std::_tstring ret(TEXT("file:///")); |
| // for (std::_tstring::iterator i = cur.begin(); i != cur.end(); i++) |
| // { |
| // if (*i == '\\') |
| // ret.append(TEXT("/")); |
| // else |
| // ret.push_back(*i); |
| // } |
| // // MessageBox(NULL, ret.c_str(), "createTempFolder", MB_OK); |
| // return ret.c_str(); |
| // } |
| |
| /** deletes the temporary folder. |
| The argument must be a file URL. |
| */ |
| // static void deleteTempFolder(const std::_tstring& sTempFolder) |
| // { |
| // if (sTempFolder.size() == 0) |
| // return; |
| // //convert the file URL to a path |
| // const std::_tstring path(sTempFolder.substr(8)); |
| // std::_tstring path2; |
| // // MessageBox(NULL, path.c_str(), "del1", MB_OK); |
| // for (std::_tstring::const_iterator i = path.begin(); i != path.end(); i++) |
| // { |
| // if (*i == '/') |
| // path2.append(TEXT("\\")); |
| // else |
| // path2.push_back(*i); |
| // } |
| |
| // //We need a null terminated string with two nulls in the end |
| // //for the SHFILEOPSTRUCT |
| // const TCHAR * szTemp = path2.c_str(); |
| // size_t size = path2.size(); |
| // TCHAR * szTemp2 = new TCHAR[size + 2]; |
| // ZeroMemory(szTemp2, (size + 2) * sizeof(TCHAR)); |
| // memcpy(szTemp2, szTemp, size * sizeof(TCHAR)); |
| |
| // // MessageBox(NULL, szTemp2, "del3", MB_OK); |
| // SHFILEOPSTRUCT operation = |
| // { |
| // NULL, |
| // FO_DELETE, |
| // szTemp2, |
| // NULL, |
| // FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR, |
| // FALSE, |
| // NULL, |
| // NULL |
| // }; |
| |
| // SHFileOperation( &operation); |
| // delete [] szTemp2; |
| // } |
| |
| |
| |
| static std::_tstring GetMsiProperty( MSIHANDLE handle, const std::_tstring& sProperty ) |
| { |
| std::_tstring result; |
| TCHAR szDummy[1] = TEXT(""); |
| DWORD nChars = 0; |
| |
| if ( MsiGetProperty( handle, sProperty.c_str(), szDummy, &nChars ) == ERROR_MORE_DATA ) |
| { |
| DWORD nBytes = ++nChars * sizeof(TCHAR); |
| LPTSTR buffer = reinterpret_cast<LPTSTR>(_alloca(nBytes)); |
| ZeroMemory( buffer, nBytes ); |
| MsiGetProperty(handle, sProperty.c_str(), buffer, &nChars); |
| result = buffer; |
| } |
| |
| return result; |
| } |
| |
| /* creates a child process which is specified in lpCommand. |
| |
| out_exitCode is the exit code of the child process |
| |
| |
| **/ |
| static BOOL ExecuteCommand( LPCTSTR lpCommand, DWORD * out_exitCode) |
| { |
| BOOL fSuccess = FALSE; |
| STARTUPINFO si; |
| PROCESS_INFORMATION pi; |
| |
| ZeroMemory( &si, sizeof(si) ); |
| si.cb = sizeof(si); |
| |
| fSuccess = CreateProcess( |
| NULL, |
| (LPTSTR)lpCommand, |
| NULL, |
| NULL, |
| FALSE, |
| 0, |
| NULL, |
| NULL, |
| &si, |
| &pi |
| ); |
| |
| if ( fSuccess ) |
| { |
| WaitForSingleObject( pi.hProcess, INFINITE ); |
| |
| if (!GetExitCodeProcess( pi.hProcess, out_exitCode)) |
| fSuccess = FALSE; |
| |
| CloseHandle( pi.hProcess ); |
| CloseHandle( pi.hThread ); |
| } |
| |
| return fSuccess; |
| } |
| |
| static BOOL RemoveCompleteDirectory( std::_tstring sPath ) |
| { |
| bool bDirectoryRemoved = true; |
| |
| std::_tstring mystr; |
| std::_tstring sPattern = sPath + TEXT("\\") + TEXT("*.*"); |
| WIN32_FIND_DATA aFindData; |
| |
| // Finding all content in sPath |
| |
| HANDLE hFindContent = FindFirstFile( sPattern.c_str(), &aFindData ); |
| |
| if ( hFindContent != INVALID_HANDLE_VALUE ) |
| { |
| bool fNextFile = false; |
| |
| do |
| { |
| std::_tstring sFileName = aFindData.cFileName; |
| std::_tstring sCurrentDir = TEXT("."); |
| std::_tstring sParentDir = TEXT(".."); |
| |
| mystr = "Current short file: " + sFileName; |
| // MessageBox(NULL, mystr.c_str(), "Current Content", MB_OK); |
| |
| if (( strcmp(sFileName.c_str(),sCurrentDir.c_str()) != 0 ) && |
| ( strcmp(sFileName.c_str(),sParentDir.c_str()) != 0 )) |
| { |
| std::_tstring sCompleteFileName = sPath + TEXT("\\") + sFileName; |
| |
| if ( aFindData.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY ) |
| { |
| bool fSuccess = RemoveCompleteDirectory(sCompleteFileName); |
| if ( fSuccess ) |
| { |
| mystr = "Successfully removed content of dir " + sCompleteFileName; |
| // MessageBox(NULL, mystr.c_str(), "Removed Directory", MB_OK); |
| } |
| else |
| { |
| mystr = "An error occurred during removing content of " + sCompleteFileName; |
| // MessageBox(NULL, mystr.c_str(), "Error removing directory", MB_OK); |
| } |
| } |
| else |
| { |
| bool fSuccess = DeleteFile( sCompleteFileName.c_str() ); |
| if ( fSuccess ) |
| { |
| mystr = "Successfully removed file " + sCompleteFileName; |
| // MessageBox(NULL, mystr.c_str(), "Removed File", MB_OK); |
| } |
| else |
| { |
| mystr = "An error occurred during removal of file " + sCompleteFileName; |
| // MessageBox(NULL, mystr.c_str(), "Error removing file", MB_OK); |
| } |
| } |
| } |
| |
| fNextFile = FindNextFile( hFindContent, &aFindData ); |
| |
| } while ( fNextFile ); |
| |
| FindClose( hFindContent ); |
| |
| // empty directory can be removed now |
| // RemoveDirectory is only successful, if the last handle to the directory is closed |
| // -> first removing content -> closing handle -> remove empty directory |
| |
| bool fRemoveDirSuccess = RemoveDirectory(sPath.c_str()); |
| |
| if ( fRemoveDirSuccess ) |
| { |
| mystr = "Successfully removed dir " + sPath; |
| // MessageBox(NULL, mystr.c_str(), "Removed Directory", MB_OK); |
| } |
| else |
| { |
| mystr = "An error occurred during removal of empty directory " + sPath; |
| // MessageBox(NULL, mystr.c_str(), "Error removing directory", MB_OK); |
| bDirectoryRemoved = false; |
| } |
| } |
| |
| return bDirectoryRemoved; |
| } |
| |
| extern "C" UINT __stdcall RegisterExtensions(MSIHANDLE handle) |
| { |
| // std::_tstring sInstDir = GetMsiProperty( handle, TEXT("INSTALLLOCATION") ); |
| std::_tstring sInstDir = GetMsiProperty( handle, TEXT("CustomActionData") ); |
| std::_tstring sUnoPkgFile = sInstDir + TEXT("program\\unopkg.exe"); |
| std::_tstring mystr; |
| |
| WIN32_FIND_DATA aFindFileData; |
| bool registrationError = false; |
| |
| // Find unopkg.exe |
| HANDLE hFindUnopkg = FindFirstFile( sUnoPkgFile.c_str(), &aFindFileData ); |
| |
| if ( hFindUnopkg != INVALID_HANDLE_VALUE ) |
| { |
| // unopkg.exe exists in program directory |
| std::_tstring sCommand = sUnoPkgFile + " sync"; |
| |
| DWORD exitCode = 0; |
| bool fSuccess = ExecuteCommand( sCommand.c_str(), & exitCode); |
| |
| // if ( fSuccess ) |
| // { |
| // mystr = "Executed successfully!"; |
| // MessageBox(NULL, mystr.c_str(), "Command", MB_OK); |
| // } |
| // else |
| // { |
| // mystr = "An error occurred during execution!"; |
| // MessageBox(NULL, mystr.c_str(), "Command", MB_OK); |
| // } |
| |
| if ( ! fSuccess ) |
| { |
| mystr = "ERROR: An error occurred during registration of extensions!"; |
| MessageBox(NULL, mystr.c_str(), "ERROR", MB_OK); |
| registrationError = true; |
| } |
| |
| FindClose( hFindUnopkg ); |
| } |
| // else |
| // { |
| // mystr = "Error: Did not find " + sUnoPkgFile; |
| // MessageBox(NULL, mystr.c_str(), "Command", MB_OK); |
| // } |
| |
| if ( registrationError ) |
| { |
| return 1; |
| } |
| else |
| { |
| return ERROR_SUCCESS; |
| } |
| } |
| |
| |
| extern "C" UINT __stdcall RemoveExtensions(MSIHANDLE handle) |
| { |
| std::_tstring mystr; |
| |
| // Finding the product with the help of the propery FINDPRODUCT, |
| // that contains a Windows Registry key, that points to the install location. |
| |
| TCHAR szValue[8192]; |
| DWORD nValueSize = sizeof(szValue); |
| HKEY hKey; |
| std::_tstring sInstDir; |
| |
| std::_tstring sProductKey = GetMsiProperty( handle, TEXT("FINDPRODUCT") ); |
| //MessageBox( NULL, sProductKey.c_str(), "Titel", MB_OK ); |
| |
| if ( ERROR_SUCCESS == RegOpenKey( HKEY_CURRENT_USER, sProductKey.c_str(), &hKey ) ) |
| { |
| if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) ) |
| { |
| sInstDir = szValue; |
| } |
| RegCloseKey( hKey ); |
| } |
| else if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE, sProductKey.c_str(), &hKey ) ) |
| { |
| if ( ERROR_SUCCESS == RegQueryValueEx( hKey, TEXT("INSTALLLOCATION"), NULL, NULL, (LPBYTE)szValue, &nValueSize ) ) |
| { |
| sInstDir = szValue; |
| } |
| RegCloseKey( hKey ); |
| } |
| else |
| { |
| return ERROR_SUCCESS; |
| } |
| |
| // Removing complete directory "Basis\presets\bundled" |
| |
| std::_tstring sCacheDir = sInstDir + TEXT("share\\prereg\\bundled"); |
| |
| bool fSuccess = RemoveCompleteDirectory( sCacheDir ); |
| |
| // if ( fSuccess ) |
| // { |
| // mystr = "Executed successfully!"; |
| // MessageBox(NULL, mystr.c_str(), "Main methode", MB_OK); |
| // } |
| // else |
| // { |
| // mystr = "An error occurred during execution!"; |
| // MessageBox(NULL, mystr.c_str(), "Main methode", MB_OK); |
| // } |
| |
| return ERROR_SUCCESS; |
| } |
