src/Utils/BugTraqAssociations.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2012 - TortoiseGit
   4 // Copyright (C) 2008 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "BugTraqAssociations.h"
  22 #include <memory>
  23 #include <initguid.h>
  24
  25 // {3494FA92-B139-4730-9591-01135D5E7831}
  26 DEFINE_GUID(CATID_BugTraqProvider,
  27                         0x3494fa92, 0xb139, 0x4730, 0x95, 0x91, 0x1, 0x13, 0x5d, 0x5e, 0x78, 0x31);
  28
  29 #define BUGTRAQ_ASSOCIATIONS_REGPATH _T("Software\\TortoiseGit\\BugTraq Associations")
  30
  31 CBugTraqAssociations::~CBugTraqAssociations()
  32 {
  33         for (inner_t::iterator it = m_inner.begin(); it != m_inner.end(); ++it)
  34                 delete *it;
  35 }
  36
  37 void CBugTraqAssociations::Load()
  38 {
  39         HKEY hk;
  40         if (RegOpenKeyEx(HKEY_CURRENT_USER, BUGTRAQ_ASSOCIATIONS_REGPATH, 0, KEY_READ, &hk) != ERROR_SUCCESS)
  41                 return;
  42
  43         for (DWORD dwIndex = 0; /* nothing */; ++dwIndex)
  44         {
  45                 TCHAR szSubKey[MAX_PATH];
  46                 DWORD cchSubKey = MAX_PATH;
  47                 LSTATUS status = RegEnumKeyEx(hk, dwIndex, szSubKey, &cchSubKey, NULL, NULL, NULL, NULL);
  48                 if (status != ERROR_SUCCESS)
  49                         break;
  50
  51                 HKEY hk2;
  52                 if (RegOpenKeyEx(hk, szSubKey, 0, KEY_READ, &hk2) == ERROR_SUCCESS)
  53                 {
  54                         TCHAR szWorkingCopy[MAX_PATH];
  55                         DWORD cbWorkingCopy = sizeof(szWorkingCopy);
  56                         RegQueryValueEx(hk2, _T("WorkingCopy"), NULL, NULL, (LPBYTE)szWorkingCopy, &cbWorkingCopy);
  57
  58                         TCHAR szClsid[MAX_PATH];
  59                         DWORD cbClsid = sizeof(szClsid);
  60                         RegQueryValueEx(hk2, _T("Provider"), NULL, NULL, (LPBYTE)szClsid, &cbClsid);
  61
  62                         CLSID provider_clsid;
  63                         CLSIDFromString(szClsid, &provider_clsid);
  64
  65                         DWORD cbParameters = 0;
  66                         RegQueryValueEx(hk2, _T("Parameters"), NULL, NULL, (LPBYTE)NULL, &cbParameters);
  67                         std::unique_ptr<TCHAR[]> szParameters(new TCHAR[cbParameters + 1]);
  68                         RegQueryValueEx(hk2, _T("Parameters"), NULL, NULL, (LPBYTE)szParameters.get(), &cbParameters);
  69                         szParameters.get()[cbParameters] = 0;
  70                         m_inner.push_back(new CBugTraqAssociation(szWorkingCopy, provider_clsid, LookupProviderName(provider_clsid), szParameters.get()));
  71
  72                         RegCloseKey(hk2);
  73                 }
  74         }
  75
  76         RegCloseKey(hk);
  77 }
  78
  79 void CBugTraqAssociations::Add(const CBugTraqAssociation &assoc)
  80 {
  81         m_inner.push_back(new CBugTraqAssociation(assoc));
  82 }
  83
  84 bool CBugTraqAssociations::FindProvider(const CTGitPathList &pathList, CBugTraqAssociation *assoc) const
  85 {
  86         return FindProviderForPathList(pathList, assoc);
  87 }
  88
  89 bool CBugTraqAssociations::FindProvider(const CString &path, CBugTraqAssociation *assoc) const
  90 {
  91
  92         CTGitPath gitpath;
  93         gitpath.SetFromUnknown(path);
  94         return FindProviderForPath(gitpath,assoc);
  95
  96 }
  97 bool CBugTraqAssociations::FindProviderForPathList(const CTGitPathList &pathList, CBugTraqAssociation *assoc) const
  98 {
  99         for (int i = 0; i < pathList.GetCount(); ++i)
 100         {
 101                 CTGitPath path = pathList[i];
 102                 if (FindProviderForPath(path, assoc))
 103                         return true;
 104         }
 105
 106         return false;
 107 }
 108
 109 bool CBugTraqAssociations::FindProviderForPath(CTGitPath path, CBugTraqAssociation *assoc) const
 110 {
 111         do
 112         {
 113                 inner_t::const_iterator it = std::find_if(m_inner.begin(), m_inner.end(), FindByPathPred(path));
 114                 if (it != m_inner.end())
 115                 {
 116                         *assoc = *(*it);
 117                         return true;
 118                 }
 119
 120                 path = path.GetContainingDirectory();
 121         } while(!path.IsEmpty());
 122
 123         return false;
 124 }
 125
 126 /* static */
 127 CString CBugTraqAssociations::LookupProviderName(const CLSID &provider_clsid)
 128 {
 129         OLECHAR szClsid[40];
 130         StringFromGUID2(provider_clsid, szClsid, ARRAYSIZE(szClsid));
 131
 132         TCHAR szSubKey[MAX_PATH];
 133         _stprintf_s(szSubKey, _T("CLSID\\%ls"), szClsid);
 134
 135         CString provider_name = CString(szClsid);
 136
 137         HKEY hk;
 138         if (RegOpenKeyEx(HKEY_CLASSES_ROOT, szSubKey, 0, KEY_READ, &hk) == ERROR_SUCCESS)
 139         {
 140                 TCHAR szClassName[MAX_PATH];
 141                 DWORD cbClassName = sizeof(szClassName);
 142
 143                 if (RegQueryValueEx(hk, NULL, NULL, NULL, (LPBYTE)szClassName, &cbClassName) == ERROR_SUCCESS)
 144                         provider_name = CString(szClassName);
 145
 146                 RegCloseKey(hk);
 147         }
 148
 149         return provider_name;
 150 }
 151
 152 LSTATUS RegSetValueFromCString(HKEY hKey, LPCTSTR lpValueName, CString str)
 153 {
 154         LPCTSTR lpsz = str;
 155         DWORD cb = (str.GetLength() + 1) * sizeof(TCHAR);
 156         return RegSetValueEx(hKey, lpValueName, 0, REG_SZ, (const BYTE *)lpsz, cb);
 157 }
 158
 159 void CBugTraqAssociations::Save() const
 160 {
 161         SHDeleteKey(HKEY_CURRENT_USER, BUGTRAQ_ASSOCIATIONS_REGPATH);
 162
 163         HKEY hk;
 164         if (RegCreateKeyEx(HKEY_CURRENT_USER, BUGTRAQ_ASSOCIATIONS_REGPATH, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hk, NULL) != ERROR_SUCCESS)
 165                 return;
 166
 167         DWORD dwIndex = 0;
 168         for (const_iterator it = begin(); it != end(); ++it)
 169         {
 170                 TCHAR szSubKey[MAX_PATH];
 171                 _stprintf_s(szSubKey, _T("%d"), dwIndex);
 172
 173                 HKEY hk2;
 174                 if (RegCreateKeyEx(hk, szSubKey, 0, NULL, 0, KEY_WRITE, NULL, &hk2, NULL) == ERROR_SUCCESS)
 175                 {
 176                         RegSetValueFromCString(hk2, _T("Provider"), (*it)->GetProviderClassAsString());
 177                         RegSetValueFromCString(hk2, _T("WorkingCopy"), (*it)->GetPath().GetWinPath());
 178                         RegSetValueFromCString(hk2, _T("Parameters"), (*it)->GetParameters());
 179
 180                         RegCloseKey(hk2);
 181                 }
 182
 183                 ++dwIndex;
 184         }
 185
 186         RegCloseKey(hk);
 187 }
 188
 189 void CBugTraqAssociations::RemoveByPath(const CTGitPath &path)
 190 {
 191         inner_t::iterator it = std::find_if(m_inner.begin(), m_inner.end(), FindByPathPred(path));
 192         if (it != m_inner.end())
 193         {
 194                 delete *it;
 195                 m_inner.erase(it);
 196         }
 197 }
 198
 199 CString CBugTraqAssociation::GetProviderClassAsString() const
 200 {
 201         OLECHAR szTemp[40];
 202         StringFromGUID2(m_provider.clsid, szTemp, ARRAYSIZE(szTemp));
 203
 204         return CString(szTemp);
 205 }
 206
 207 /* static */
 208 std::vector<CBugTraqProvider> CBugTraqAssociations::GetAvailableProviders()
 209 {
 210         std::vector<CBugTraqProvider> results;
 211
 212         ICatInformation *pCatInformation = NULL;
 213
 214         HRESULT hr;
 215         if (SUCCEEDED(hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_ALL, IID_ICatInformation, (void **)&pCatInformation)))
 216         {
 217                 IEnumGUID *pEnum = NULL;
 218                 if (SUCCEEDED(hr = pCatInformation->EnumClassesOfCategories(1, &CATID_BugTraqProvider, 0, NULL, &pEnum)))
 219                 {
 220                         HRESULT hrEnum;
 221                         do
 222                         {
 223                                 CLSID clsids[5];
 224                                 ULONG cClsids;
 225
 226                                 hrEnum = pEnum->Next(ARRAYSIZE(clsids), clsids, &cClsids);
 227                                 if (SUCCEEDED(hrEnum))
 228                                 {
 229                                         for (ULONG i = 0; i < cClsids; ++i)
 230                                         {
 231                                                 CBugTraqProvider provider;
 232                                                 provider.clsid = clsids[i];
 233                                                 provider.name = LookupProviderName(clsids[i]);
 234                                                 results.push_back(provider);
 235                                         }
 236                                 }
 237                         } while (hrEnum == S_OK);
 238                 }
 239
 240                 if (pEnum)
 241                         pEnum->Release();
 242                 pEnum = NULL;
 243         }
 244
 245         if (pCatInformation)
 246                 pCatInformation->Release();
 247         pCatInformation = NULL;
 248
 249         return results;
 250 }