Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
hmmapi.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 46k
Category:

Windows Kernel

Development Platform:

Visual C++

hmmapi.cpp：Code Content
  1. #include "pch.hxx"
  2. #include <winuser.h>
  3. #include <hlink.h>
  4. #include <shellapi.h>
  5. #define INITGUID
  6. #include <initguid.h>
  7. #include <exdisp.h>
  8. #include <tchar.h>
  10. #define USENAVIGATE     1
  11. #define USEATTFILE 1
  12. #define USEPOST 0
  14. #define ARRAYSIZE(buf) (sizeof(buf) / sizeof(buf[0]))
  16. HINSTANCE       g_hInstMAPI = NULL;
  18. ////////////////////////////////////////////////////////////////////////
  19. //
  20. //  dll entry point
  21. //
  22. ////////////////////////////////////////////////////////////////////////
  23. STDAPI_(BOOL) APIENTRY DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID lpRsrvd)
  24. {
  25.     switch (dwReason)
  26. {
  27. case DLL_PROCESS_ATTACH:
  28. g_hInstMAPI = hDll;
  29. break;
  31. case DLL_PROCESS_DETACH:
  32. break;
  33. } // switch
  34.     return(TRUE);
  35. }
  37. BOOL FRunningOnNTEx(LPDWORD pdwVersion)
  38. {
  39.     static BOOL fIsNT = 2 ;
  40.     static DWORD dwVersion = (DWORD)0;
  41.     OSVERSIONINFO VerInfo;
  42.     
  43.     // If we have calculated this before just pass that back.
  44.     // else find it now.
  45.     //
  46.     if (fIsNT == 2)
  47.     {
  48.         VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  49.         
  50.         GetVersionEx(&VerInfo);
  51.         // Also, we don't check for failure on the above call as it
  52.         // should succeed if we are on NT 4.0 or Win 9X!
  53.         //
  54.         fIsNT = (VerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
  55.         if (fIsNT)
  56.             dwVersion = VerInfo.dwMajorVersion;
  57.     }
  58.     if (pdwVersion)
  59.         *pdwVersion = dwVersion;
  60.     
  61.     return fIsNT;
  62. }
  63. // Then next 2 functions are stollen from shlwapi. Needed to modiy them, because
  64. // we had to handle SFN.
  65. // Also there is a bug in the Ansi versin of ExpandEnvironmentStrings, where the
  66. // function returns the number of bytes the string would have if it would be
  67. // UNICODE. Since we have to convert the string anyway to SFN I use lstrlen to 
  68. // get the real length.
  69. //
  70. //  If the given environment variable exists as the first part of the path,
  71. //  then the environment variable is inserted into the output buffer.
  72. //
  73. //  Returns TRUE if pszResult is filled in.
  74. //
  75. //  Example:  Input  -- C:WINNTSYSTEM32FOO.TXT -and- lpEnvVar = %SYSTEMROOT%
  76. //            Output -- %SYSTEMROOT%SYSTEM32FOO.TXT
  77. //
  78. BOOL MyUnExpandEnvironmentString(LPCTSTR pszPath, LPCTSTR pszEnvVar, LPTSTR pszResult, UINT cbResult)
  79. {
  80.     TCHAR szEnvVar[MAX_PATH];
  81.     DWORD dwEnvVar = SHExpandEnvironmentStrings(pszEnvVar, szEnvVar, ARRAYSIZE(szEnvVar));
  83.     if (dwEnvVar)
  84.     {
  85.         // Convert the string to short file name
  86.         GetShortPathName(szEnvVar, szEnvVar, ARRAYSIZE(szEnvVar));
  87.         dwEnvVar = lstrlen(szEnvVar);
  88.         if (CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, szEnvVar, dwEnvVar, pszPath, dwEnvVar) == 2)
  89.         {
  90.             if (lstrlen(pszPath) - (int)dwEnvVar + lstrlen(pszEnvVar) < (int)cbResult)
  91.             {
  92.                 lstrcpy(pszResult, pszEnvVar);
  93.                 lstrcat(pszResult, pszPath + dwEnvVar);
  94.                 return TRUE;
  95.             }
  96.         }
  97.     }
  98.     return FALSE;
  99. }
  102. // note: %USERPROFILE% is relative to the user making the call, so this does
  103. // not work if we are being impresonated from a service, for example
  104. // dawrin installs apps from the system process this way
  105. STDAPI_(BOOL) MyPathUnExpandEnvStrings(LPCTSTR pszPath, LPTSTR pszBuf, UINT cchBuf)
  106. {
  107.     if (pszPath && pszBuf)
  108.     {
  109.         return (MyUnExpandEnvironmentString(pszPath, TEXT("%USERPROFILE%"), pszBuf, cchBuf)       ||
  110.                 MyUnExpandEnvironmentString(pszPath, TEXT("%ALLUSERSPROFILE%"), pszBuf, cchBuf)   ||
  111.                 MyUnExpandEnvironmentString(pszPath, TEXT("%ProgramFiles%"), pszBuf, cchBuf)      ||
  112.                 MyUnExpandEnvironmentString(pszPath, TEXT("%SystemRoot%"), pszBuf, cchBuf)        ||
  113.                 MyUnExpandEnvironmentString(pszPath, TEXT("%SystemDrive%"), pszBuf, cchBuf));
  114.     }
  115.     else
  116.     {
  117.         return FALSE;
  118.     }
  119. }
  123. static void GetPostUrl(LPSTR lpszData, DWORD dwSize)
  124. {
  125. HKEY hkDefClient;
  126. HKEY hkClient;
  127. TCHAR szClient[64];
  128. DWORD type;
  129. DWORD dwClientSize = sizeof(TCHAR) * 64;
  131. LONG err = RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\Clients\Mail"), &hkClient);
  132. if (err == ERROR_SUCCESS)
  133. {
  134. err = RegQueryValueEx(hkClient, NULL, 0, &type, (LPBYTE)szClient, &dwClientSize);
  135. if (err == ERROR_SUCCESS)
  136. {
  137. err = RegOpenKey(hkClient, szClient, &hkDefClient);
  138. if (err == ERROR_SUCCESS)
  139. {
  140. DWORD type;
  141. err = RegQueryValueEx(hkDefClient, TEXT("posturl"), 0, &type, (LPBYTE)lpszData, &dwSize);
  142. RegCloseKey(hkDefClient);
  143. }
  144. }
  145. RegCloseKey(hkClient);
  146. }
  147. if (err != ERROR_SUCCESS)
  148.     {
  149.         LoadString(g_hInstMAPI, IDS_DEFAULTPOSTURL, lpszData, dwSize);
  150.     }
  151. }
  153. typedef HRESULT (STDAPICALLTYPE DynNavigate)(DWORD grfHLNF, LPBC pbc, IBindStatusCallback *pibsc,
  154.  LPCWSTR pszTargetFrame, LPCWSTR pszUrl, LPCWSTR pszLocation);
  155. typedef DynNavigate FAR *LPDynNavigate;
  157. STDAPI HlinkFrameNavigateNHL(DWORD grfHLNF, LPBC pbc, IBindStatusCallback *pibsc,
  158.  LPCWSTR pszTargetFrame, LPCWSTR pszUrl, LPCWSTR pszLocation)
  159. {
  160. HRESULT hr;
  161.     HINSTANCE   hinst;
  162. LPDynNavigate fpNavigate = NULL;
  164. hinst = LoadLibraryA("SHDOCVW.DLL");
  166.     // If that failed because the module was not be found,
  167.     // then try to find the module in the directory we were
  168.     // loaded from.
  170.     if (!hinst)
  171. goto Error;
  173.     fpNavigate = (LPDynNavigate)GetProcAddress(hinst, "HlinkFrameNavigateNHL");
  174.     if (!fpNavigate)
  175. goto Error;
  177.     hr = fpNavigate(grfHLNF, pbc, pibsc, pszTargetFrame, pszUrl, pszLocation);
  179. FreeLibrary(hinst);
  180. return hr;
  182. Error:
  183.     return GetLastError();
  184. }
  186. static void SimpleNavigate(LPTSTR lpszUrl, BOOL bUseFrame = false)
  187. {
  188.     DWORD cch = (lstrlen(lpszUrl) + 1);
  189. LPWSTR pwszData = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cch * sizeof(WCHAR));
  190.     if (pwszData)
  191.     {
  192.         SHTCharToUnicode(lpszUrl, pwszData, cch);
  193.         if (bUseFrame)
  194.             HlinkFrameNavigateNHL(HLNF_OPENINNEWWINDOW, NULL, NULL, NULL, pwszData, NULL);
  195.         else
  196.             HlinkSimpleNavigateToString(pwszData, NULL, NULL, NULL, NULL, NULL, 0, 0);
  197.         HeapFree(GetProcessHeap(), 0, (LPVOID)pwszData);
  198.     }
  199. }
  201. // Pack some data into a SAFEARRAY of BYTEs. Return in a VARIANT
  202. static HRESULT GetPostData(LPVARIANT pvPostData, LPTSTR lpszData)
  203. {
  204. HRESULT hr;
  205. LPSAFEARRAY psa;
  206. UINT cElems = lstrlen(lpszData);
  207. LPSTR pPostData;
  209. if (!pvPostData)
  210. return E_POINTER;
  212. VariantInit(pvPostData);
  214. psa = SafeArrayCreateVector(VT_UI1, 0, cElems);
  215. if (!psa)
  216. return E_OUTOFMEMORY;
  218. hr = SafeArrayAccessData(psa, (LPVOID*)&pPostData);
  219. memcpy(pPostData, lpszData, cElems);
  220. hr = SafeArrayUnaccessData(psa);
  222. V_VT(pvPostData) = VT_ARRAY | VT_UI1;
  223. V_ARRAY(pvPostData) = psa;
  224. return NOERROR;
  225. }
  227. static void DoNavigate(LPTSTR lpszUrl, LPTSTR lpszData, BOOL bPlainIntf = TRUE)
  228. {
  229. HRESULT hr;
  230. IWebBrowser2* pWBApp = NULL; // Derived from IWebBrowser
  231. BSTR bstrURL = NULL, bstrHeaders = NULL;
  232. VARIANT vFlags = {0};
  233. VARIANT vTargetFrameName = {0};
  234. VARIANT vPostData = {0};
  235. VARIANT vHeaders = {0};
  236. LPWSTR pwszData = NULL;
  237. LPTSTR pszUrl = NULL;
  238.     DWORD cch;
  240. if (FAILED(hr = CoInitialize(NULL)))
  241. return;
  243. if (FAILED(hr = CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_SERVER, IID_IWebBrowser2, (LPVOID*)&pWBApp)))
  244. goto Error;
  246. #if USEPOST
  247.     cch = lstrlen(lpszUrl) + 1;
  248. pwszData = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cch * sizeof(WCHAR));
  249. if (!pwszData)
  250. goto Error;
  252.     SHTCharToUnicode(lpszUrl, pwszData, cch);
  253. bstrURL = SysAllocString(pwszData);
  254. HeapFree(GetProcessHeap(), 0, (LPVOID)pwszData);
  255. if (!bstrURL)
  256. goto Error;
  258. bstrHeaders = SysAllocString(L"Content-Type: application/x-www-form-urlencodedrn");
  259. if (!bstrHeaders)
  260. goto Error;
  262. V_VT(&vHeaders) = VT_BSTR;
  263. V_BSTR(&vHeaders) = bstrHeaders;
  265. hr = GetPostData(&vPostData, lpszData);
  266. hr = pWBApp->Navigate(bstrURL, &vFlags, &vTargetFrameName, &vPostData, &vHeaders);
  267. #else
  268.     cch = lstrlen(lpszUrl) + lstrlen(lpszData) + 2;
  269. pszUrl = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cch * sizeof(TCHAR));
  270. if (!pszUrl)
  271. goto Error;
  272. lstrcpy(pszUrl, lpszUrl);
  273. lstrcat(pszUrl, "?");
  274. lstrcat(pszUrl, lpszData);
  275. cch = lstrlen(pszUrl) + 1;
  276. pwszData = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cch * sizeof(WCHAR));
  277. if (!pwszData)
  278. {
  279. HeapFree(GetProcessHeap(), 0, (LPVOID)pszUrl);
  280. goto Error;
  281. }
  283.     SHTCharToUnicode(pszUrl, pwszData, cch);
  284. HeapFree(GetProcessHeap(), 0, (LPVOID)pszUrl);
  285. bstrURL = SysAllocString(pwszData);
  286. HeapFree(GetProcessHeap(), 0, (LPVOID)pwszData);
  287. if (!bstrURL)
  288. goto Error;
  290. hr = pWBApp->Navigate(bstrURL, &vFlags, &vTargetFrameName, &vPostData, &vHeaders);
  291. #endif
  292. if (bPlainIntf)
  293. {
  294. pWBApp->put_AddressBar(VARIANT_FALSE);
  295. pWBApp->put_MenuBar(VARIANT_FALSE);
  296. pWBApp->put_ToolBar(VARIANT_FALSE);
  297. }
  298. pWBApp->put_Visible(VARIANT_TRUE);
  300. Error:
  301. if (bstrURL)
  302. SysFreeString(bstrURL);
  303. if (bstrHeaders)
  304. SysFreeString(bstrHeaders);
  305. VariantClear(&vPostData);
  306. if (pWBApp)
  307. pWBApp->Release();
  308. CoUninitialize();
  309. }
  311. // Helpers for Form Submit - copied from IE3 and modified approriately
  312. //
  313. static char x_hex_digit(int c)
  314. {
  315.     if (c >= 0 && c <= 9)
  316.     {
  317. return c + '0';
  318.     }
  319.     if (c >= 10 && c <= 15)
  320.     {
  321. return c - 10 + 'A';
  322.     }
  323.     return '0';
  324. }
  326. static const unsigned char isAcceptable[96] =
  327. /*   0 1 2 3 4 5 6 7 8 9 A B C D E F */
  328. {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0,    /* 2x   !"#$%&'()*+,-./  */
  329.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,    /* 3x  0123456789:;<=>?  */
  330.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 4x  @ABCDEFGHIJKLMNO  */
  331.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,    /* 5x  PQRSTUVWXYZ[]^_  */
  332.  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,    /* 6x  `abcdefghijklmno  */
  333.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};   /* 7x  pqrstuvwxyz{}~  DEL */
  335. // Performs URL-encoding of null-terminated strings. Pass NULL in pbOut
  336. // to find buffer length required. Note that '' is not written out.
  338. // 2/9/99  cchLimit param added for safety -- no more than cchLimit chars are
  339. // written out.  If pbOut is NULL then cchLimit is ignored.  If the caller uses 
  340. // the style Buffer[URLEncode(Buffer, ...)] = 0, then cchLimit should be the 
  341. // buffer size minus one.
  342.    
  343. int
  344. URLEncode(LPTSTR pbOut, const char * pchIn, const int cchLimit)
  345. {
  346.     int     lenOut = 0;
  347.     char *  pchOut = (char *)pbOut;
  349.     for (; *pchIn && (!pchOut || lenOut < cchLimit); pchIn++, lenOut++)
  350.     {
  351.         if (*pchIn == ' ')
  352.         {
  353.             if (pchOut)
  354.                 *pchOut++ = '+';
  355.         }
  356.         else if (*pchIn >= 32 && *pchIn <= 127 && isAcceptable[*pchIn - 32])
  357.         {
  358.             if (pchOut)
  359.                 *pchOut++ = (TCHAR)*pchIn;
  360.         }
  361.         else
  362.         {
  363.             if (pchOut) 
  364.             {
  365.                 if (lenOut <= cchLimit - 3)
  366.                 {
  367.                     // enough room for this encoding
  368.                     *pchOut++ = '%';
  369.                     *pchOut++ = x_hex_digit((*pchIn >> 4) & 0xf);
  370.                     *pchOut++ = x_hex_digit(*pchIn & 0xf);
  371.                     lenOut += 2; 
  372.                 }
  373.                 else
  374.                     return lenOut;
  375.             }
  376.             else
  377.                 lenOut += 2; // for expression handles 3rd inc  
  378.         }
  379.     }
  381.     return lenOut;
  382. }
  385. ///////////////////////////////////////////////////////////////////////
  386. //
  387. // MAPILogon
  388. //
  389. ///////////////////////////////////////////////////////////////////////
  391. ULONG FAR PASCAL MAPILogon(ULONG ulUIParam,
  392.    LPSTR lpszProfileName,
  393.    LPSTR lpszPassword,
  394.    FLAGS flFlags,
  395.    ULONG ulReserved,
  396.    LPLHANDLE lplhSession)
  397. {
  398. *lplhSession = 1;
  399. return SUCCESS_SUCCESS;
  400. }
  403. ///////////////////////////////////////////////////////////////////////
  404. //
  405. // MAPILogoff
  406. //
  407. ///////////////////////////////////////////////////////////////////////
  409. ULONG FAR PASCAL MAPILogoff(LHANDLE lhSession,
  410.     ULONG ulUIParam,
  411.     FLAGS flFlags,
  412.     ULONG ulReserved)
  413. {
  414. return SUCCESS_SUCCESS;
  415. }
  418. ///////////////////////////////////////////////////////////////////////
  419. //
  420. // MAPIFreeBuffer
  421. //
  422. ///////////////////////////////////////////////////////////////////////
  424. ULONG FAR PASCAL MAPIFreeBuffer(LPVOID lpv)
  425. {
  426. return MAPI_E_FAILURE;
  427. }
  430. ///////////////////////////////////////////////////////////////////////
  431. //
  432. // MAPISendMail
  433. //
  434. ///////////////////////////////////////////////////////////////////////
  436. ULONG FAR PASCAL MAPISendMail(LHANDLE lhSession,          
  437.                   ULONG ulUIParam,
  438.                   lpMapiMessage lpMessage,
  439.                   FLAGS flFlags,
  440.                   ULONG ulReserved)
  441. {
  442.     TCHAR szUrl[256];
  444.     GetPostUrl(szUrl, sizeof(TCHAR) * 256);
  445.     
  446.     // Calculate the buffer size needed to create the url
  447.     ULONG i;
  448. #if USENAVIGATE
  449.     DWORD dwUrlSize = 32; // "?action=compose" + slop
  450. #else
  451.     DWORD dwUrlSize = lstrlen(szUrl) + 32; // "?action=compose" + slop
  452. #endif
  453.     DWORD dwMaxSize = 0;
  454.     DWORD dwSize;
  455.     DWORD dwFileSizes = 0;
  456.     HANDLE hFile;
  458.     if (lpMessage->lpszSubject)
  459.     {
  460.         dwSize = URLEncode(NULL, lpMessage->lpszSubject, 0);
  461.         dwMaxSize = max(dwMaxSize, dwSize + 1);
  462.         dwUrlSize += dwMaxSize + 9; // "&subject=%s"
  463.     }
  464.     if (lpMessage->lpszNoteText)
  465.     {
  466.         dwSize = URLEncode(NULL, lpMessage->lpszNoteText, 0);
  467.         dwMaxSize = max(dwMaxSize, dwSize + 1);
  468.         dwUrlSize += dwSize + 6; // "&body=%s"
  469.     }
  471.     for (i = 0; i < lpMessage->nRecipCount; i++)
  472.     {
  473.         dwSize = URLEncode(NULL, lpMessage->lpRecips[i].lpszName, 0);
  474.         dwMaxSize = max(dwMaxSize, dwSize + 1);
  475.         dwUrlSize += dwSize + 4; // "&to=%s" || "&cc=%s"
  476.         if (lpMessage->lpRecips[i].ulRecipClass == MAPI_BCC)
  477.             dwUrlSize++; // extra character for bcc
  478.     }
  480.     if (lpMessage->nFileCount)
  481.     {
  482.         dwUrlSize += 14; // "&filecount=xxx"
  483.         for (i = 0; i < lpMessage->nFileCount; i++)
  484.         {
  485.             if (!lpMessage->lpFiles[i].lpszPathName)
  486.                 continue;
  488.             TCHAR szFileSize[32];
  490.             hFile = CreateFile(lpMessage->lpFiles[i].lpszPathName, 0 /*GENERIC_READ*/, 0 /*FILE_SHARE_READ*/, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  491.             if (hFile == INVALID_HANDLE_VALUE)
  492.             {
  493.                 LPVOID lpMsgBuf;
  494.                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
  495.                 MessageBox(NULL, (char*)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION);
  496.                 LocalFree(lpMsgBuf);
  497.                 continue;
  498.             }
  499.             dwSize = GetFileSize(hFile, NULL);
  500.             CloseHandle(hFile);
  501.             if (dwSize == -1)
  502.                 continue;
  503.             dwFileSizes += dwSize;
  504.             wnsprintf(szFileSize, ARRAYSIZE(szFileSize), "&size%d=%d", i, dwSize);
  505.             dwSize = lstrlen(szFileSize);
  506.             dwMaxSize = max(dwMaxSize, dwSize + 1);
  507.             dwUrlSize += dwSize;
  510.             dwSize = URLEncode(NULL, lpMessage->lpFiles[i].lpszPathName, 0) + 4;    // in case we need to append a ^
  511.             dwMaxSize = max(dwMaxSize, dwSize + 1);
  512.             dwUrlSize += dwSize + 9; // "&pathxxx=%s"
  514.             if (lpMessage->lpFiles[i].lpszFileName)
  515.             {
  516.                 dwSize = URLEncode(NULL, lpMessage->lpFiles[i].lpszFileName, 0);
  517.                 dwMaxSize = max(dwMaxSize, dwSize + 1);
  518.                 dwUrlSize += dwSize + 9; // "&filexxx=%s"
  519.             }
  520. #if USEATTFILE
  521.             else 
  522.             {
  523.                 // ATTFILE code further down just tacks on the path when lpszFileName is NULL
  524.                 dwUrlSize += URLEncode(NULL, lpMessage->lpFiles[i].lpszPathName, 0) + 4;
  525.             }
  526. #endif
  527.         }
  528.     }
  530. #if USEATTFILE
  531.     dwSize = ARRAYSIZE("&attfile=") + (URLEncode(NULL, "::", 0) * lpMessage->nFileCount * 3);
  532. #else
  533.     dwSize = ARRAYSIZE("&filecount=xxx");
  534. #endif
  535.     dwMaxSize = max(dwMaxSize, dwSize + 1);
  536.     dwUrlSize += dwSize;
  538.     LPTSTR pszData = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwUrlSize * sizeof(TCHAR));
  540.     if (!pszData)
  541.         return MAPI_E_FAILURE;
  543.     LPTSTR pszBuf = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwMaxSize * sizeof(TCHAR));
  545.     if (!pszBuf) 
  546.     {
  547.         HeapFree(GetProcessHeap(), 0, (LPVOID) pszData);
  548.         return MAPI_E_FAILURE;
  549.     }
  551.     // Build the URL
  552. #if USENAVIGATE
  553.     lstrcpyn(pszData, "action=compose", dwUrlSize);
  554. #else
  555.     wnsprintf(pszData, dwUrlSize, "%s?action=compose", szUrl);
  556. #endif
  558.     for (i = 0; i < lpMessage->nRecipCount; i++)
  559.     {
  560.         switch (lpMessage->lpRecips[i].ulRecipClass)
  561.         {
  562.             case MAPI_TO:
  563.                 StrCatBuff(pszData, "&to=", dwUrlSize);
  564.                 break;
  565.             case MAPI_CC:
  566.                 StrCatBuff(pszData, "&cc=", dwUrlSize);
  567.                 break;
  568.             case MAPI_BCC:
  569.                 StrCatBuff(pszData, "&bcc=", dwUrlSize);
  570.                 break;
  571.         }
  572.         pszBuf[URLEncode(pszBuf, lpMessage->lpRecips[i].lpszName, dwMaxSize-1)] = 0;
  573.         StrCatBuff(pszData, pszBuf, dwUrlSize);
  574.     }
  575.     if (lpMessage->lpszSubject)
  576.     {
  577.         StrCatBuff(pszData, "&subject=", dwUrlSize);
  578.         pszBuf[URLEncode(pszBuf, lpMessage->lpszSubject, dwMaxSize-1)] = 0;
  579.         StrCatBuff(pszData, pszBuf, dwUrlSize);
  580.     }
  581.     if (lpMessage->lpszNoteText)
  582.     {
  583.         StrCatBuff(pszData, "&body=", dwUrlSize);
  584.         pszBuf[URLEncode(pszBuf, lpMessage->lpszNoteText, dwMaxSize-1)] = 0;
  585.         StrCatBuff(pszData, pszBuf, dwUrlSize);
  586.     }
  587.     if (lpMessage->nFileCount)
  588.     {
  589. #if USEATTFILE
  590.         TCHAR szSep[32];
  591.         TCHAR szPath[MAX_PATH];
  592.         TCHAR szTemp[MAX_PATH];
  593.         GetTempPath(MAX_PATH - 1, szTemp);
  594.         BOOL bIsTemp;
  596.         StrCatBuff(pszData, "&attfile=", dwUrlSize);
  597. #else
  598.         wnsprintf(pszBuf, dwMaxSize, "&filecount=%d", lpMessage->nFileCount);
  599.         StrCatBuff(pszData, pszBuf, dwUrlSize);
  600. #endif
  601.         for (i = 0; i < lpMessage->nFileCount; i++)
  602.         {
  603.             if (!lpMessage->lpFiles[i].lpszPathName)
  604.                 continue;
  606.             bIsTemp = FALSE;
  607.             lstrcpyn(szPath, lpMessage->lpFiles[i].lpszPathName, ARRAYSIZE(szPath));
  608.             hFile = CreateFile(szPath, 0, 0 /*GENERIC_READ, FILE_SHARE_READ*/, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  609.             if (hFile == INVALID_HANDLE_VALUE)
  610.                 continue;
  611.             dwSize = GetFileSize(hFile, NULL);
  612.             // Handle the case where this is a temporary file
  613.             if (CompareString(LOCALE_SYSTEM_DEFAULT, 0, szTemp, lstrlen(szTemp), szPath, lstrlen(szTemp)) == CSTR_EQUAL)
  614.             {
  615.                 // If the file was created in the last 2 seconds assume that it is really temporary
  616.                 FILETIME ftLastWrite, ftSystem;
  617.                 LARGE_INTEGER liLastWrite, liSystem;
  618.                 if (GetFileTime(hFile, NULL, NULL, &ftLastWrite))
  619.                 {
  620.                     GetSystemTimeAsFileTime(&ftSystem);
  621.                     liLastWrite.LowPart = ftLastWrite.dwLowDateTime;
  622.                     liLastWrite.HighPart = ftLastWrite.dwHighDateTime;
  623.                     liSystem.LowPart = ftSystem.dwLowDateTime;
  624.                     liSystem.HighPart = ftSystem.dwHighDateTime;
  625.                     //jeffif (liLastWrite.QuadPart - liSystem.QuadPart < 30000000L)
  626.                         bIsTemp = TRUE;
  627.                 }
  628.             }
  629.             CloseHandle(hFile);
  630.             if (dwSize == -1)
  631.                 continue;
  632.             if (bIsTemp)
  633.             {
  634.                 StrCatBuff(szPath, "^", ARRAYSIZE(szPath));
  635.                 MoveFile(lpMessage->lpFiles[i].lpszPathName, szPath);
  636.                 SetFileAttributes(szPath, FILE_ATTRIBUTE_READONLY);
  637.             }
  638. #if USEATTFILE
  639.             szSep[URLEncode(szSep, "::", ARRAYSIZE(szSep)-1)] = 0;
  640.             pszBuf[URLEncode(pszBuf, szPath, dwMaxSize-1)] = 0;
  641.             StrCatBuff(pszData, pszBuf, dwUrlSize);
  642.             StrCatBuff(pszData, szSep, dwUrlSize);
  643.             if (lpMessage->lpFiles[i].lpszFileName)
  644.             {
  645.                 pszBuf[URLEncode(pszBuf, lpMessage->lpFiles[i].lpszFileName, dwMaxSize-1)] = 0;
  646.                 StrCatBuff(pszData, pszBuf, dwUrlSize);
  647.             }
  648.             else
  649.                 StrCatBuff(pszData, pszBuf, dwUrlSize);
  650.             StrCatBuff(pszData, szSep, dwUrlSize);
  651.             wnsprintf(szSep, ARRAYSIZE(szSep), "^%d;", dwSize);
  652.             pszBuf[URLEncode(pszBuf, szSep, dwMaxSize-1)] = 0;
  653.             StrCatBuff(pszData, pszBuf, dwUrlSize);
  654. #else
  655.             wnsprintf(pszBuf, dwMaxSize, "&size%d=%d", i, dwSize);
  656.             StrCatBuff(pszData, pszBuf, dwUrlSize);
  658.             wnsprintf(pszBuf, dwMaxSize, "&path%d=", i);
  659.             StrCatBuff(pszData, pszBuf, dwUrlSize);
  660.             pszBuf[URLEncode(pszBuf, szPath, dwMaxSize-1)] = 0;
  661.             StrCatBuff(pszData, pszBuf, dwUrlSize);
  663.             if (lpMessage->lpFiles[i].lpszFileName)
  664.             {
  665.                 wnsprintf(pszBuf, dwMaxSize-1, "&file%d=", i);
  666.                 StrCatBuff(pszData, pszBuf, dwUrlSize);
  667.                 pszBuf[URLEncode(pszBuf, lpMessage->lpFiles[i].lpszFileName, dwMaxSize-1)] = 0;
  668.                 StrCatBuff(pszData, pszBuf, dwUrlSize);
  669.             }
  670. #endif
  671.         }
  672.     }
  673.     HeapFree(GetProcessHeap(), 0, (LPVOID)pszBuf);
  675. #if USENAVIGATE
  676.     DoNavigate(szUrl, pszData, FALSE);
  677. #else
  678.     SimpleNavigate(pszData, TRUE);
  679. #endif
  680.     HeapFree(GetProcessHeap(), 0, (LPVOID)pszData);
  682.     return SUCCESS_SUCCESS;
  683. }
  685. ///////////////////////////////////////////////////////////////////////
  686. //
  687. // MAPISendDocuments
  688. //
  689. ///////////////////////////////////////////////////////////////////////
  691. ULONG FAR PASCAL MAPISendDocuments(ULONG ulUIParam,
  692.    LPSTR lpszDelimChar,
  693.    LPSTR lpszFullPaths,
  694.    LPSTR lpszFileNames,
  695.    ULONG ulReserved)
  696. {
  697. return MAPI_E_FAILURE;
  698. }
  701. ///////////////////////////////////////////////////////////////////////
  702. //
  703. // MAPIAddress
  704. //
  705. ///////////////////////////////////////////////////////////////////////
  707. ULONG FAR PASCAL MAPIAddress(LHANDLE lhSession,
  708.      ULONG ulUIParam,
  709.      LPTSTR lpszCaption,
  710.      ULONG nEditFields,
  711.      LPTSTR lpszLabels,
  712.      ULONG nRecips,
  713.      lpMapiRecipDesc lpRecips,
  714.      FLAGS flFlags,
  715.      ULONG ulReserved,
  716.      LPULONG lpnNewRecips,
  717.      lpMapiRecipDesc FAR * lppNewRecips)
  718. {
  719. return MAPI_E_FAILURE;
  720. }
  723. ///////////////////////////////////////////////////////////////////////
  724. //
  725. // MAPIDetails
  726. //
  727. ///////////////////////////////////////////////////////////////////////
  729. ULONG FAR PASCAL MAPIDetails(LHANDLE lhSession,
  730.      ULONG ulUIParam,
  731.      lpMapiRecipDesc lpRecip,
  732.      FLAGS flFlags,
  733.      ULONG ulReserved)
  734. {
  735. return MAPI_E_FAILURE;
  736. }
  738. ///////////////////////////////////////////////////////////////////////
  739. //
  740. // MAPIResolveName
  741. //
  742. ///////////////////////////////////////////////////////////////////////
  744. ULONG FAR PASCAL MAPIResolveName(LHANDLE lhSession,
  745.  ULONG ulUIParam,
  746.  LPSTR lpszName,
  747.  FLAGS flFlags,
  748.  ULONG ulReserved,
  749.  lpMapiRecipDesc FAR *lppRecip)
  750. {
  751. return MAPI_E_FAILURE;
  752. }
  755. ///////////////////////////////////////////////////////////////////////
  756. //
  757. // MAPIFindNext
  758. //
  759. ///////////////////////////////////////////////////////////////////////
  761. ULONG FAR PASCAL MAPIFindNext(LHANDLE lhSession,
  762.       ULONG ulUIParam,
  763.       LPSTR lpszMessageType,
  764.       LPSTR lpszSeedMessageID,
  765.       FLAGS flFlags,
  766.       ULONG ulReserved,
  767.       LPSTR lpszMessageID)
  768. {
  769. return MAPI_E_FAILURE;
  770. }
  772. ///////////////////////////////////////////////////////////////////////
  773. //
  774. // MAPIReadMail
  775. //
  776. ///////////////////////////////////////////////////////////////////////
  778. ULONG FAR PASCAL MAPIReadMail(LHANDLE lhSession,
  779.       ULONG ulUIParam,
  780.       LPSTR lpszMessageID,
  781.       FLAGS flFlags,
  782.       ULONG ulReserved,
  783.       lpMapiMessage FAR *lppMessage)
  784. {
  785. return MAPI_E_FAILURE;
  786. }
  789. ///////////////////////////////////////////////////////////////////////
  790. //
  791. // MAPISaveMail
  792. //
  793. ///////////////////////////////////////////////////////////////////////
  795. ULONG FAR PASCAL MAPISaveMail(LHANDLE lhSession,
  796.       ULONG ulUIParam,
  797.       lpMapiMessage lpMessage,
  798.       FLAGS flFlags,
  799.       ULONG ulReserved,
  800.       LPSTR lpszMessageID)
  801. {
  802. return MAPI_E_FAILURE;
  803. }
  805. ///////////////////////////////////////////////////////////////////////
  806. //
  807. // MAPIDeleteMail
  808. //
  809. ///////////////////////////////////////////////////////////////////////
  811. ULONG FAR PASCAL MAPIDeleteMail(LHANDLE lhSession,
  812. ULONG ulUIParam,
  813. LPSTR lpszMessageID,
  814. FLAGS flFlags,
  815. ULONG ulReserved)
  816. {
  817. return MAPI_E_FAILURE;
  818. }
  821. ///////////////////////////////////////////////////////////////////////
  822. //
  823. // BMAPISendMail
  824. //
  825. ///////////////////////////////////////////////////////////////////////
  827. BMAPI_ENTRY BMAPISendMail (LHANDLE                      hSession,
  828.    ULONG                        ulUIParam,
  829.    LPVB_MESSAGE         lpM,
  830.    LPSAFEARRAY *        lppsaRecips,
  831.    LPSAFEARRAY *        lppsaFiles,
  832.    ULONG                        flFlags,
  833.    ULONG                        ulReserved)
  834. {
  835. return MAPI_E_FAILURE;
  836. }
  838. ///////////////////////////////////////////////////////////////////////
  839. //
  840. // BMAPIFindNext
  841. //
  842. ///////////////////////////////////////////////////////////////////////
  843. BMAPI_ENTRY BMAPIFindNext( LHANDLE      hSession,       // Session
  844.    ULONG        ulUIParam,      // UIParam
  845.    BSTR *       lpbstrType,     // MessageType
  846.    BSTR *       lpbstrSeed,     // Seed message Id
  847.    ULONG        flFlags,        // Flags
  848.    ULONG        ulReserved,     // Reserved
  849.    BSTR *       lpbstrId) 
  850. {
  851. return MAPI_E_FAILURE;
  852. }
  854. ///////////////////////////////////////////////////////////////////////
  855. //
  856. // BMAPIReadMail
  857. //
  858. ///////////////////////////////////////////////////////////////////////
  859. BMAPI_ENTRY BMAPIReadMail( LPULONG      lpulMessage,    // pointer to output data (out)
  860.    LPULONG      nRecips,        // number of recipients (out)
  861.    LPULONG      nFiles,         // number of file attachments (out)
  862.    LHANDLE      hSession,       // Session
  863.    ULONG        ulUIParam,      // UIParam
  864.    BSTR *       lpbstrID,       // Message Id
  865.    ULONG        flFlags,        // Flags
  866.    ULONG        ulReserved )    // Reserved
  867. {
  868. return MAPI_E_FAILURE;
  869. }
  871. ///////////////////////////////////////////////////////////////////////
  872. //
  873. // BMAPIGetReadMail
  874. //
  875. ///////////////////////////////////////////////////////////////////////
  876. BMAPI_ENTRY BMAPIGetReadMail( ULONG             lpMessage,       // Pointer to MAPI Mail
  877.       LPVB_MESSAGE      lpvbMessage, // Pointer to VB Message Buffer (out)
  878.       LPSAFEARRAY * lppsaRecips, // Pointer to VB Recipient Buffer (out)
  879.       LPSAFEARRAY * lppsaFiles,  // Pointer to VB File attachment Buffer (out)
  880.       LPVB_RECIPIENT lpvbOrig)   // Pointer to VB Originator Buffer (out)
  881. {
  882. return MAPI_E_FAILURE;
  883. }
  885. ///////////////////////////////////////////////////////////////////////
  886. //
  887. // BMAPISaveMail
  888. //
  889. ///////////////////////////////////////////////////////////////////////
  890. BMAPI_ENTRY BMAPISaveMail( LHANDLE                      hSession,       // Session
  891.    ULONG                        ulUIParam,      // UIParam
  892.    LPVB_MESSAGE         lpM,            // Pointer to VB Message Buffer
  893.    LPSAFEARRAY *        lppsaRecips,    // Pointer to VB Recipient Buffer
  894.    LPSAFEARRAY *        lppsaFiles,     // Pointer to VB File Attacment Buffer
  895.    ULONG                        flFlags,        // Flags
  896.    ULONG                        ulReserved,     // Reserved
  897.    BSTR *                       lpbstrID)       // Message ID
  898. {
  899. return MAPI_E_FAILURE;
  900. }
  902. ///////////////////////////////////////////////////////////////////////
  903. //
  904. // BMAPIAddress
  905. //
  906. ///////////////////////////////////////////////////////////////////////
  908. BMAPI_ENTRY BMAPIAddress( LPULONG                       lpulRecip,       // Pointer to New Recipient Buffer (out)
  909.   LHANDLE                       hSession,        // Session
  910.   ULONG                         ulUIParam,       // UIParam
  911.   BSTR *                        lpbstrCaption,   // Caption string
  912.   ULONG                         ulEditFields,    // Number of Edit Controls
  913.   BSTR *                        lpbstrLabel,     // Label string
  914.   LPULONG                       lpulRecipients,  // Pointer to number of Recipients (in/out)
  915.   LPSAFEARRAY *         lppsaRecip,      // Pointer to Initial Recipients VB_RECIPIENT
  916.   ULONG                         ulFlags,         // Flags
  917.   ULONG                         ulReserved )     // Reserved
  918. {
  919. return MAPI_E_FAILURE;
  920. }
  922. ///////////////////////////////////////////////////////////////////////
  923. //
  924. // BMAPIGetAddress
  925. //
  926. ///////////////////////////////////////////////////////////////////////
  928. BMAPI_ENTRY BMAPIGetAddress (ULONG                      ulRecipientData, // Pointer to recipient data
  929.      ULONG                      cRecipients,     // Number of recipients
  930.  LPSAFEARRAY *  lppsaRecips )    // VB recipient array
  931. {
  932. return MAPI_E_FAILURE;
  933. }
  935. ///////////////////////////////////////////////////////////////////////
  936. //
  937. // BMAPIDetails
  938. //
  939. ///////////////////////////////////////////////////////////////////////
  941. BMAPI_ENTRY BMAPIDetails (LHANDLE                       hSession,   // Session
  942.   ULONG                         ulUIParam,      // UIParam
  943.   LPVB_RECIPIENT        lpVB,           // Pointer to VB recipient stucture
  944.   ULONG                         ulFlags,    // Flags
  945.   ULONG                         ulReserved) // Reserved
  947. {
  948. return MAPI_E_FAILURE;
  949. }
  951. ///////////////////////////////////////////////////////////////////////
  952. //
  953. // BMAPIResolveName
  954. //
  955. ///////////////////////////////////////////////////////////////////////
  957. BMAPI_ENTRY BMAPIResolveName (LHANDLE                   hSession,     // Session
  958.       ULONG                     ulUIParam,    // UIParam
  959.       BSTR                              bstrMapiName, // Name to be resolved
  960.       ULONG                     ulFlags,      // Flags
  961.       ULONG                     ulReserved,   // Reserved
  962.       LPVB_RECIPIENT    lpVB)             // Pointer to VB recipient structure (out)
  963. {
  964. return MAPI_E_FAILURE;
  965. }
  967. ///////////////////////////////////////////////////////////////////////
  968. //
  969. // MailToProtocolHandler
  970. //
  971. ///////////////////////////////////////////////////////////////////////
  973. void CALLBACK MailToProtocolHandler(HWND      hwnd,
  974.     HINSTANCE hinst,
  975. LPSTR     lpszCmdLine,
  976. int       nCmdShow)
  977. {
  978. TCHAR pszUrl[256];
  980. GetPostUrl(pszUrl, sizeof(TCHAR) * 256);
  981. #if USENAVIGATE
  982. LPTSTR pszData = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlen(lpszCmdLine) + 32) * sizeof(TCHAR));
  984. wsprintf(pszData, "action=compose&to=%s", &lpszCmdLine[7]);
  985. // Convert the extraneous '?' to '&'
  986. for (LPTSTR p = pszData; *p; p++)
  987. if (*p == '?')
  988. *p = '&';
  990. DoNavigate(pszUrl, pszData, FALSE);
  992. HeapFree(GetProcessHeap(), 0, (LPVOID)pszData);
  993. #else
  994. LPTSTR pszData = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlen(lpszCmdLine) + lstrlen(pszUrl) + 32) * sizeof(TCHAR));
  996. wsprintf(pszData, "%s?action=compose&to=%s", pszUrl, &lpszCmdLine[7]);
  997. // Convert the extraneous '?' to '&'
  998. for (LPTSTR p = &pszData[lstrlen(pszUrl) + 1]; *p; p++)
  999. if (*p == '?')
  1000. *p = '&';
  1002. SimpleNavigate(pszData);
  1004. HeapFree(GetProcessHeap(), 0, (LPVOID)pszData);
  1005. #endif
  1006. }
  1008. ///////////////////////////////////////////////////////////////////////
  1009. //
  1010. // OpenInboxHandler
  1011. //
  1012. ///////////////////////////////////////////////////////////////////////
  1014. void CALLBACK OpenInboxHandler(HWND      hwnd,
  1015.        HINSTANCE hinst,
  1016.    LPSTR     lpszCmdLine,
  1017.    int       nCmdShow)
  1018. {
  1019. TCHAR pszUrl[256];
  1021. GetPostUrl(pszUrl, sizeof(TCHAR) * 256);
  1023. #if USENAVIGATE
  1024. DoNavigate(pszUrl, "action=inbox", FALSE);
  1025. #else
  1026. LPTSTR pszData = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlen(pszUrl) + 32) * sizeof(TCHAR));
  1028. wsprintf(pszData, "%s?action=inbox", pszUrl);
  1029. SimpleNavigate(pszData);
  1031. HeapFree(GetProcessHeap(), 0, (LPVOID)pszData);
  1032. #endif
  1033. }
  1035. ///////////////////////////////////////////////////////////////////////
  1036. //
  1037. // Layout of Registry Usage
  1038. //
  1039. //
  1040. // HKEY_CLASSES_ROOTmailto
  1041. // HKEY_CLASSES_ROOTmailtoDefaultIcon
  1042. // HKEY_CLASSES_ROOTmailtoshellopencommand
  1043. //
  1044. // HKEY_LOCAL_MACHINESOFTWAREClientsMail
  1045. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmail
  1046. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmailProtocolsmailto
  1047. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmailProtocolsmailtoDefaultIcon
  1048. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmailProtocolsmailtoshellopencommand
  1049. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmailshellopencommand
  1050. // HKEY_LOCAL_MACHINESOFTWAREClientsMailHotmailbackup
  1051. //
  1052. ///////////////////////////////////////////////////////////////////////
  1054. #define MAILTO          TEXT("mailto")
  1055. #define PROTOCOLS       TEXT("Protocols")
  1056. #define DEFAULTICON     TEXT("DefaultIcon")
  1057. #define COMMAND         TEXT("shell\open\command")
  1058. #define MAIL            TEXT("SOFTWARE\Clients\Mail")
  1059. #define POSTURL         TEXT("posturl")
  1060. #define BACKUP          TEXT("backup")
  1063. ///////////////////////////////////////////////////////////////////////
  1064. //
  1065. // SetRegStringValue
  1066. //
  1067. ///////////////////////////////////////////////////////////////////////
  1069. static LONG SetRegStringValue(HKEY hkKey, LPTSTR lpszKey, LPTSTR lpszValue, LPTSTR lpszPath, DWORD dwType)
  1070. {
  1071.     if (!(dwType == REG_SZ) && !(dwType == REG_EXPAND_SZ))
  1072.         return ERROR_INVALID_PARAMETER;
  1074. if (lpszPath)
  1075. {
  1076. TCHAR szValue[MAX_PATH + 32];
  1077. wsprintf(szValue, lpszValue, lpszPath);
  1078. return RegSetValueEx(hkKey, lpszKey, 0, dwType, (LPBYTE)szValue, (lstrlen(szValue) + 1) * sizeof(TCHAR));
  1079. }
  1081. return RegSetValueEx(hkKey, lpszKey, 0, dwType, (LPBYTE)lpszValue, (lstrlen(lpszValue) + 1) * sizeof(TCHAR));
  1082. }
  1084. ///////////////////////////////////////////////////////////////////////
  1085. //
  1086. // CreateMailToEntries
  1087. //
  1088. ///////////////////////////////////////////////////////////////////////
  1090. static LONG CreateMailToEntries(HKEY hkKey, TCHAR* lpszPath, BOOL fRegExpandSz)
  1091. {
  1092. LONG err;
  1093. HKEY hkMailToProt;
  1094. HKEY hkDefaultIcon;
  1095. HKEY hkCommand;
  1097. err = RegCreateKey(hkKey, MAILTO, &hkMailToProt);
  1098. if (err == ERROR_SUCCESS)
  1099. {
  1100. err = SetRegStringValue(hkMailToProt, NULL, TEXT("URL:MailTo Protocol"), NULL, REG_SZ);
  1101. if (err == ERROR_SUCCESS)
  1102. {
  1103. DWORD editFlags = 2; 
  1104. err = RegSetValueEx(hkMailToProt, TEXT("EditFlags"), 0, REG_BINARY, (LPBYTE)&editFlags, sizeof(DWORD));
  1105. }
  1106. if (err == ERROR_SUCCESS)
  1107. err = SetRegStringValue(hkMailToProt, TEXT("URL Protocol"), TEXT(""), NULL, REG_SZ);
  1109. if (err == ERROR_SUCCESS)
  1110. err = RegCreateKey(hkMailToProt, DEFAULTICON, &hkDefaultIcon);
  1111. if (err == ERROR_SUCCESS)
  1112. {
  1113. err = SetRegStringValue(hkDefaultIcon, NULL, "%s,1", lpszPath, fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1114. RegCloseKey(hkDefaultIcon);
  1115. }
  1117. if (err == ERROR_SUCCESS)
  1118. err = RegCreateKey(hkMailToProt, COMMAND, &hkCommand);
  1119. if (err == ERROR_SUCCESS)
  1120. {
  1121.             DWORD dwNTVer = 0;
  1122.             // BUGBUG: Only the rundll32 on NT5 can handle double quotes around the path
  1123.             // Lucky on Win9x and NT4 the epand sz path will never be a long file name and the old
  1124.             // rundll32 works, but we cannot have double quotes
  1125.             if (FRunningOnNTEx(&dwNTVer) && (dwNTVer >= 5))
  1126.             {
  1127.                 err = SetRegStringValue(hkCommand, NULL, "rundll32.exe "%s",MailToProtocolHandler %%1", lpszPath, fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1128.             }
  1129.             else
  1130.             {
  1131.                 err = SetRegStringValue(hkCommand, NULL, "rundll32.exe %s,MailToProtocolHandler %%1", lpszPath, fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1132.             }
  1133. RegCloseKey(hkCommand);
  1134. }
  1135. RegCloseKey(hkMailToProt);
  1136. }
  1137. return err;
  1138. }
  1140. ///////////////////////////////////////////////////////////////////////
  1141. //
  1142. // DoAddService
  1143. //
  1144. ///////////////////////////////////////////////////////////////////////
  1146. STDAPI DoAddService(LPSTR lpszService, LPSTR lpszPostURL)
  1147. {
  1148. LONG err;
  1149.     TCHAR szLongPath[MAX_PATH];
  1150.     TCHAR szPath[MAX_PATH];
  1151. HKEY hkClientsMail;
  1152. HKEY hkService;
  1153. HKEY hkProtocols;
  1154. HKEY hkCommand;
  1155. HKEY hkBackup;
  1156.     BOOL fExistingMailClient = FALSE;
  1157.     BOOL fRegExpandSz = FALSE;
  1159.     GetModuleFileName(g_hInstMAPI, szLongPath, MAX_PATH);  // get path to this DLL
  1160.     GetShortPathName(szLongPath, szPath, MAX_PATH);
  1162. // First setup the info for the protocol in clients section
  1163. err = RegCreateKey(HKEY_LOCAL_MACHINE, MAIL, &hkClientsMail);
  1164. if (err == ERROR_SUCCESS)
  1165. {
  1166.         fRegExpandSz = MyPathUnExpandEnvStrings(szPath, szLongPath, ARRAYSIZE(szLongPath));
  1167.         if (fRegExpandSz)
  1168.             lstrcpy(szPath, szLongPath);
  1169. err = RegCreateKey(hkClientsMail, lpszService, &hkService);
  1170. if (err == ERROR_SUCCESS)
  1171. {
  1172. err = SetRegStringValue(hkService, NULL, lpszService, NULL, REG_SZ);
  1173. if (err == ERROR_SUCCESS)
  1174.             {
  1175.                 err = SetRegStringValue(hkService, TEXT("DLLPath"), szPath, NULL,
  1176.                                           fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1177.             }
  1178. if (err == ERROR_SUCCESS && lpszPostURL && lstrlen(lpszPostURL))
  1179. err = SetRegStringValue(hkService, TEXT("posturl"), lpszPostURL, NULL, REG_SZ);
  1180. if (err == ERROR_SUCCESS)
  1181. err = RegCreateKey(hkService, PROTOCOLS, &hkProtocols);
  1182. if (err == ERROR_SUCCESS)
  1183. {
  1184. err = CreateMailToEntries(hkProtocols, szPath, fRegExpandSz);
  1185. RegCloseKey(hkProtocols);
  1186. }
  1187. if (err == ERROR_SUCCESS)
  1188. err = RegCreateKey(hkService, COMMAND, &hkCommand);
  1189. if (err == ERROR_SUCCESS)
  1190. {
  1191.                 DWORD dwNTVer = 0;
  1192.                 // BUGBUG: Only the rundll32 on NT5 can handle double quotes around the path
  1193.                 // Lucky on Win9x and NT4 the epand sz path will never be a long file name and the old
  1194.                 // rundll32 works, but we cannot have double quotes
  1195.                 if (FRunningOnNTEx(&dwNTVer) && (dwNTVer >= 5))
  1196.                 {
  1197.     err = SetRegStringValue(hkCommand, NULL, "rundll32.exe "%s",OpenInboxHandler", szPath,
  1198.                                             fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1199.                 }
  1200.                 else
  1201.                 {
  1202.     err = SetRegStringValue(hkCommand, NULL, "rundll32.exe %s,OpenInboxHandler", szPath,
  1203.                                             fRegExpandSz?REG_EXPAND_SZ:REG_SZ);
  1204.                 }
  1205. RegCloseKey(hkCommand);
  1206. }
  1207. if (err == ERROR_SUCCESS)
  1208. err = RegCreateKey(hkService, BACKUP, &hkBackup);
  1209. if (err == ERROR_SUCCESS)
  1210. {
  1211. TCHAR szValue[MAX_PATH];
  1212. DWORD size;
  1213. DWORD type;
  1214. HKEY hkDefaultIcon;
  1215. HKEY hkCommand;
  1217. err = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("mailto\DefaultIcon"), &hkDefaultIcon);
  1218. if (err == ERROR_SUCCESS)
  1219. {
  1220. size = sizeof(TCHAR) * MAX_PATH;
  1221. err = RegQueryValueEx(hkDefaultIcon, NULL, 0, &type, (LPBYTE)szValue, &size);
  1222. if (err == ERROR_SUCCESS)
  1223. err = RegSetValueEx(hkBackup, DEFAULTICON, 0, type, (LPBYTE)szValue, size);
  1224. RegCloseKey(hkDefaultIcon);
  1225. }
  1227. err = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("mailto\shell\open\command"), &hkCommand);
  1228. if (err == ERROR_SUCCESS)
  1229. {
  1230. size = sizeof(TCHAR) * MAX_PATH;
  1231. err = RegQueryValueEx(hkCommand, NULL, 0, &type, (LPBYTE)szValue, &size);
  1232. if (err == ERROR_SUCCESS)
  1233.                     {
  1234.                         fExistingMailClient = TRUE;
  1235. err = RegSetValueEx(hkBackup, TEXT("command"), 0, type, (LPBYTE)szValue, size);
  1236.                     }
  1237. RegCloseKey(hkCommand);
  1238. }
  1240. size = sizeof(TCHAR) * MAX_PATH;
  1241. err = RegQueryValueEx(hkClientsMail, NULL, 0, &type, (LPBYTE)szValue, &size);
  1242. if (err == ERROR_SUCCESS)
  1243. err = RegSetValueEx(hkBackup, TEXT("mail"), 0, type, (LPBYTE)szValue, size);
  1245. RegCloseKey(hkBackup);
  1246. }
  1247.     RegCloseKey(hkService);
  1248. }
  1249. if (err == ERROR_SUCCESS && !fExistingMailClient)
  1250. SetRegStringValue(hkClientsMail, NULL, lpszService, NULL, REG_SZ);
  1251.     RegCloseKey(hkClientsMail);
  1252. }
  1253. if (err == ERROR_SUCCESS && !fExistingMailClient)
  1254. err = CreateMailToEntries(HKEY_CLASSES_ROOT, szPath, fRegExpandSz);
  1256.     //
  1257.     // REVIEW Backup fails sometimes. Need to clean up registry changes and 
  1258.     // probably remove all backup registry entirely.
  1259.     // For now just safe to return S_OK
  1260.     // 
  1261. #if 0
  1262.     if (err != ERROR_SUCCESS)
  1263. return HRESULT_FROM_WIN32(err);
  1264. #else
  1265.     return S_OK;
  1266. #endif
  1267. }
  1269. ///////////////////////////////////////////////////////////////////////
  1270. //
  1271. // DeleteKeyAndSubKeys
  1272. //
  1273. ///////////////////////////////////////////////////////////////////////
  1275. static LONG DeleteKeyAndSubKeys(HKEY hkIn, LPCTSTR pszSubKey)
  1276. {
  1277.     HKEY  hk;
  1278.     TCHAR szTmp[MAX_PATH];
  1279.     DWORD dwTmpSize;
  1280.     long  l;
  1281.     int   x;
  1283. l = RegOpenKeyEx(hkIn, pszSubKey, 0, KEY_ALL_ACCESS, &hk);
  1284. if (l != ERROR_SUCCESS) 
  1285. return l;
  1287.     // loop through all subkeys, blowing them away.
  1288.     //
  1289.     x = 0;
  1290.     while (l == ERROR_SUCCESS)
  1291. {
  1292. dwTmpSize = MAX_PATH;
  1293. l = RegEnumKeyEx(hk, 0, szTmp, &dwTmpSize, 0, NULL, NULL, NULL);
  1294. if (l != ERROR_SUCCESS)
  1295.     break;
  1297. l = DeleteKeyAndSubKeys(hk, szTmp);
  1298.     }
  1300.     // there are no subkeys left, [or we'll just generate an error and return FALSE].
  1301.     // let's go blow this dude away.
  1302.     //
  1303. RegCloseKey(hk);
  1304.     return RegDeleteKey(hkIn, pszSubKey);
  1305. }
  1307. ///////////////////////////////////////////////////////////////////////
  1308. //
  1309. // DoRemoveService
  1310. //
  1311. ///////////////////////////////////////////////////////////////////////
  1313. STDAPI DoRemoveService(LPSTR lpszService)
  1314. {
  1315. TCHAR szValue[MAX_PATH];
  1316. DWORD size;
  1317. LONG err;
  1318. DWORD type;
  1319. HKEY hkDefaultIcon;
  1320. HKEY hkCommand;
  1321. HKEY hkBackup;
  1322. HKEY hkService;
  1323. HKEY hkClientsMail;
  1325.     //
  1326. // Restore the previous values if HMMAPI is the current provider
  1327.     //
  1328. err = RegOpenKey(HKEY_LOCAL_MACHINE, MAIL, &hkClientsMail);
  1329. if (err == ERROR_SUCCESS)
  1330. {
  1331.         //
  1332.         // Find the name of the current provider
  1333.         //
  1334.         TCHAR szCurrent[MAX_PATH];
  1335.         DWORD cb = sizeof(szCurrent);
  1336.         err = RegQueryValueEx(hkClientsMail, NULL, NULL, NULL, (LPBYTE)szCurrent, &cb);
  1337.         if (err == ERROR_SUCCESS)
  1338.         {
  1339.             //
  1340.             // Check if it is HMMAPI
  1341.             //
  1342.             if (StrCmp(szCurrent, lpszService) == 0)
  1343.             {
  1344.         err = RegOpenKey(hkClientsMail, lpszService, &hkService);
  1345.         if (err == ERROR_SUCCESS)
  1346.         {
  1347.         err = RegOpenKey(hkService, BACKUP, &hkBackup);
  1348.         if (err == ERROR_SUCCESS)
  1349.         {
  1350.         err = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("mailto\DefaultIcon"), &hkDefaultIcon);
  1351.         if (err == ERROR_SUCCESS)
  1352.         {
  1353.                             size = sizeof(TCHAR) * MAX_PATH;
  1354.         err = RegQueryValueEx(hkBackup, DEFAULTICON, 0, &type, (LPBYTE)szValue, &size);
  1355.         if (err == ERROR_SUCCESS)
  1356.         err = RegSetValueEx(hkDefaultIcon, NULL, 0, type, (LPBYTE)szValue, size);
  1357.         RegCloseKey(hkDefaultIcon);
  1358.         }
  1360.         err = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("mailto\shell\open\command"), &hkCommand);
  1361.         if (err == ERROR_SUCCESS)
  1362.         {
  1363.         size = sizeof(TCHAR) * MAX_PATH;
  1364.         err = RegQueryValueEx(hkBackup, TEXT("command"), 0, &type, (LPBYTE)szValue, &size);
  1365.         if (err == ERROR_SUCCESS)
  1366.         err = RegSetValueEx(hkCommand, NULL, 0, type, (LPBYTE)szValue, size);
  1367.         RegCloseKey(hkCommand);
  1368.         }
  1370.         size = sizeof(TCHAR) * MAX_PATH;
  1371.         err = RegQueryValueEx(hkBackup, TEXT("mail"), 0, &type, (LPBYTE)szValue, &size);
  1372.         if (err == ERROR_SUCCESS)
  1373.         err = RegSetValueEx(hkClientsMail, NULL, 0, type, (LPBYTE)szValue, size);
  1375.         RegCloseKey(hkBackup);
  1376.         }
  1377.         RegCloseKey(hkService);
  1378.         }
  1379.             }
  1380.             err = DeleteKeyAndSubKeys(hkClientsMail, lpszService);
  1381.         }
  1382.         RegCloseKey(hkClientsMail);
  1383. }
  1385.     //
  1386.     // REVIEW Backup fails sometimes. Need to clean up registry changes and 
  1387.     // probably remove all backup registry entirely.
  1388.     // For now just safe to return S_OK
  1389.     // 
  1390. #if 0
  1391.     if (err != ERROR_SUCCESS)
  1392. return HRESULT_FROM_WIN32(err);
  1393. #else
  1394.     return S_OK;
  1395. #endif
  1396. }
  1398. ///////////////////////////////////////////////////////////////////////
  1399. //
  1400. // AddService
  1401. //
  1402. ///////////////////////////////////////////////////////////////////////
  1404. void CALLBACK AddService(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
  1405. {
  1406. LPSTR lpszService = lpszCmdLine;
  1407. LPSTR lpszPostUrl = NULL;
  1409. if (*lpszService == '"')
  1410. {
  1411. lpszService++;
  1412. lpszPostUrl = StrChr(lpszService, '"');
  1413. if (lpszPostUrl)
  1414. {
  1415. *lpszPostUrl = 0;
  1416. lpszPostUrl++;
  1417. while (*lpszPostUrl && *lpszPostUrl == ' ')
  1418. lpszPostUrl++;
  1419. if (*lpszPostUrl == 0)
  1420. lpszPostUrl = NULL;
  1421. }
  1422. }
  1423. else
  1424. {
  1425. lpszPostUrl = StrChr(lpszService, ' ');
  1426. if (lpszPostUrl)
  1427. {
  1428. *lpszPostUrl = 0;
  1429. lpszPostUrl++;
  1430. }
  1431. }
  1432. DoAddService(lpszService, lpszPostUrl);
  1433. }
  1435. ///////////////////////////////////////////////////////////////////////
  1436. //
  1437. // RemoveService
  1438. //
  1439. ///////////////////////////////////////////////////////////////////////
  1441. void CALLBACK RemoveService(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
  1442. {
  1443. DWORD dwLen = (lpszCmdLine) ? lstrlen(lpszCmdLine) : 0;
  1445. if (dwLen)
  1446. {
  1447. if (*lpszCmdLine == '"' && lpszCmdLine[dwLen - 1] == '"')
  1448. {
  1449. lpszCmdLine[dwLen - 1] = 0;
  1450. lpszCmdLine++;
  1451. }
  1452. DoRemoveService(lpszCmdLine);
  1453. }
  1454. }
  1456. ///////////////////////////////////////////////////////////////////////
  1457. //
  1458. // DllRegisterServer
  1459. //
  1460. ///////////////////////////////////////////////////////////////////////
  1462. STDAPI DllRegisterServer(void)
  1463. {
  1464.     return DoAddService(TEXT("Hotmail"), NULL);
  1465. }
  1467. ///////////////////////////////////////////////////////////////////////
  1468. //
  1469. // DllUnregisterServer
  1470. //
  1471. ///////////////////////////////////////////////////////////////////////
  1473. STDAPI DllUnregisterServer(void)
  1474. {
  1475.     return DoRemoveService(TEXT("Hotmail"));
  1476. }