July, 2008

BOOL HostExec(LPCTSTR lpszFilePath, HANDLE *phProcess)
{
    BOOL bRet;
    SHELLEXECUTEINFO sei = {0};

    sei.cbSize = sizeof(sei);
    sei.nShow = SW_SHOWNORMAL;
    sei.lpFile = lpszFilePath;
    //sei.lpParameters = TEXT("/silent");  //WRONG APPROACH!!

    bRet = ShellExecuteEx(&sei);

    if (bRet)
    {
        *phProcess = sei.hProcess;
    }

    return bRet;
}

BOOL HostExec(LPCTSTR lpszFilePath, HANDLE *phProcess)
{
    BOOL bRet;
    SHELLEXECUTEINFO sei = {0};

    sei.cbSize = sizeof(sei);
    sei.nShow = SW_SHOWNORMAL; 
    sei.lpFile = TEXT("\\Windows\\WCELOAD.EXE");

    TCHAR   szLaunchParms[MAX_PATH];
    StringCchPrintf(szLaunchParms,ARRAYSIZE(szLaunchParms), 
            TEXT("/silent \"%s\""), 
            lpszFilePath);
    sei.lpParameters = szLaunchParms;

    bRet = ShellExecuteEx(&sei);

    if (bRet)
    {
        *phProcess = sei.hProcess;
    }

    return bRet;
}

using System;
using System.Net;

namespace ExchangeSDK.Snippets.CSharp
{
   class DeletingItemsWebDAV
   {
      [STAThread]
      static void Main(string[] args)
      {
         System.Net.HttpWebRequest Request;
         System.Net.WebResponse Response;
         System.Net.CredentialCache MyCredentialCache;
         string strSourceURI = "http://server/public/TestFolder1/test.txt";

         //In this sample user credentials are hard-coded for didactic purposes
         string strUserName = "UserName";
         string strPassword = "!Password";
         string strDomain = "Domain";

         try
         {
            // Create a new CredentialCache object and fill it with the network
            // credentials required to access the server. 
            // we won't pass the credentials in clear-text...
            MyCredentialCache = new System.Net.CredentialCache();
            MyCredentialCache.Add( new System.Uri(strSourceURI),
               "NTLM",
               new System.Net.NetworkCredential(strUserName, strPassword, strDomain)
               );

            // Create the HttpWebRequest object.
            Request = (System.Net.HttpWebRequest)HttpWebRequest.Create(strSourceURI);

            // Add the network credentials to the request.
            Request.Credentials = MyCredentialCache;

            // Specify the DELETE method.
            Request.Method = "DELETE";

            // Send the DELETE method request.
            Response = (System.Net.HttpWebResponse)Request.GetResponse();

            // Close the HttpWebResponse object.
            Response.Close();

            Console.WriteLine("Item successfully deleted.");

         }
         catch(Exception ex)
         {
            // Catch any exceptions. Any error codes from the DELETE
            // method request on the server will be caught here, also.
            Console.WriteLine(ex.Message);
         }
      }
   }
}

#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>

#include <initguid.h>
#include <pimstore.h>
#include <mapiutil.h>

HRESULT hr = E_FAIL;
LPMAPISESSION m_pSession;

////////////////////////////////////////////////////////////////////////////// 
//Functions declarations
HRESULT CreateEntryList(SRowSet *pRows, ENTRYLIST **ppList);
HRESULT DeleteMessages(IMsgStore* pStore);
HRESULT GetWastebasketForFolder(LPMAPIFOLDER pFolder, LPMAPIFOLDER* ppfldrWastebasket);
ULONG CountMessagesInFolder(LPMAPIFOLDER pFolder);
HRESULT CreateEntryList(SRowSet *pRows, ENTRYLIST **ppList);

////////////////////////////////////////////////////////////////////////////// 
//Macros
#define _ErrorLabel Error

#define CHR(hResult) \
    if(FAILED(hResult)) { hr = (hResult); goto _ErrorLabel;} 

#define CPR(pPointer) \
    if(NULL == (pPointer)) { hr = (E_OUTOFMEMORY); goto _ErrorLabel;} 

#define CBR(fBool) \
    if(!(fBool)) { hr = (E_FAIL); goto _ErrorLabel;} 

#define ARRAYSIZE(s) (sizeof(s) / sizeof(s[0]))

#define RELEASE_OBJ(s)  \
    if (NULL != s)      \
    {                   \
        s->Release();   \
        s = NULL;       \
    }


//////////////////////////////////////////////////////////////////////////////// 
//MAIN
int _tmain(int argc, _TCHAR* argv[])
{
    SRowSet *prowset = NULL;
    IMAPITable* ptbl = NULL;
    IMsgStore* pStore = NULL;

    // Warn user that the messages will be permanently deleting 
    int iResult = ::MessageBox(GetActiveWindow(), 
                TEXT("Are you sure you want to permanently delete all messages in Deleted Items ON THE DEVICE?"), 
                TEXT("Permanently Delete Items"), MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2);

    // If IDYES - then continue / else exit method now
    hr = (iResult == IDYES) ? S_OK : E_FAIL;                        
    CHR(hr);

    //Initialize MAPI COM Server
    hr = MAPIInitialize(NULL);    
    CHR(hr);

    //Logon to MAPI and get a session pointer
    hr = MAPILogonEx(0, NULL, NULL, 0, (LPMAPISESSION *)&m_pSession);
    CHR(hr);

    static const SizedSPropTagArray (2, spta) = { 2, PR_DISPLAY_NAME, PR_ENTRYID };
        
    // Get the table of accounts
    hr = m_pSession->GetMsgStoresTable(0, &ptbl);
    CHR(hr);

    // set the columns of the table we will query
    hr = ptbl->SetColumns((SPropTagArray *) &spta, 0);
    CHR(hr);

    while (TRUE)
    {
        // Free the previous row
        FreeProws (prowset);
        prowset = NULL;
 
        hr = ptbl->QueryRows (1, 0, &prowset);
        if ((hr != S_OK) || (prowset == NULL) || (prowset->cRows == 0))
            break;
 
        ASSERT (prowset->aRow[0].cValues == spta.cValues);
        SPropValue *pval = prowset->aRow[0].lpProps;
 
        ASSERT (pval[0].ulPropTag == PR_DISPLAY_NAME);
        ASSERT (pval[1].ulPropTag == PR_ENTRYID);
 
        //Windows Movile has 2 MAPI Message Stores: "ActiveSync" and "SMS"
        if (!_tcscmp(pval[0].Value.lpszW, TEXT("ActiveSync")))
        {
            // Get the Message Store pointer
            hr = m_pSession->OpenMsgStore(0, pval[1].Value.bin.cb, (LPENTRYID)pval[1].Value.bin.lpb, 0, 0, &pStore);
            CHR(hr);
 
            //Empty Deleted Items folder
            hr = EmptyDeletedMessages(pStore);
            CHR(hr);
        }
    }

    //finishing off...
    hr = m_pSession->Logoff(0, 0, 0);
    
Error:
    //make sure we don't leak memory
    FreeProws(prowset);
    RELEASE_OBJ(ptbl);
    RELEASE_OBJ(pStore);
    RELEASE_OBJ(m_pSession);   

    MAPIUninitialize();

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
// EmptyDeletedMessages - Takes the Message Store as argument and empties its 
//  Deleted Items folder
HRESULT EmptyDeletedMessages(IMsgStore* pStore)
{
    hr = E_FAIL;
    ULONG cMsgCount = 0;
    IMAPIFolder* pFolder = NULL;
    IMAPIFolder* pWasteBasket = NULL;
    IMAPITable *pTable = NULL; 
    ULONG cbEntryId = 0;
    ENTRYID *pEntryId = NULL;
    ULONG ulObjType = 0;
    SRowSet *pRows = NULL;
    LPENTRYLIST lpmsgEntryList = NULL;

    // First retrieve the ENTRYID of the Inbox folder of the message store
    hr = pStore->GetReceiveFolder(NULL, MAPI_UNICODE, &cbEntryId, &pEntryId, NULL); 
    CHR(hr);
 
    // We have the entryid of the inbox folder, let's get the folder and messages in it
    hr = pStore->OpenEntry(cbEntryId, pEntryId, NULL, 0, &ulObjType, (LPUNKNOWN*)&pFolder);
    CHR(hr);
 
    // Be sure it's a folder
    ASSERT(ulObjType == MAPI_FOLDER);

    // Get the Deleted Items Folder (because it may be that current view is on wahtever folder
    hr = GetWastebasketForFolder(pFolder, &pWasteBasket);
    CHR(hr);
    CPR(pWasteBasket);

    // Get contents of the folder
    pWasteBasket->GetContentsTable(MAPI_UNICODE, &pTable);

    // We only care about the EntryID. 
    SizedSPropTagArray (1, spta) = {1, PR_ENTRYID};
    pTable->SetColumns((SPropTagArray *)&spta, 0);

    BOOL done = FALSE;

    // We need to know how many messages there are
    cMsgCount = CountMessagesInFolder(pWasteBasket);
    
    while(cMsgCount > 0)
    {
        // 10 is the max number of rows which QueryRows can return
        int cCurrentQuery = 0;

        if (cMsgCount > 10)
        {
            cCurrentQuery = 10;
        }
        else
        {
            cCurrentQuery = cMsgCount;
        }
        
        hr = pTable->QueryRows(cCurrentQuery, 0, &pRows);
        CHR(hr);
        
        // Did we hit the end of the table?
        if (pRows->cRows == 0)
        {   
            break;
        }

        // Since we are in a loop here and we are re-using lpmsgEntryList 
        // we may need to free the memory from the previous iteration first
        // In the case of the last iteration or Error - this will be freed at Error:
        MAPIFreeBuffer(lpmsgEntryList);
        lpmsgEntryList = NULL;
        
        // Otherwise - Get the List of EntryIDs from the RowSet as an EntryList
        //  Note: the resulting will EntryList be dependant on the RowSet so don't free until later
        hr = CreateEntryList(pRows, &lpmsgEntryList);
        CHR(hr);  


        // permanently delete the items 
        hr = pWasteBasket->DeleteMessages(lpmsgEntryList, NULL, NULL, NULL);
        CHR(hr);           
        
        cMsgCount -= pRows->cRows;
    }  

Error:
    RELEASE_OBJ(pFolder);
    RELEASE_OBJ(pWasteBasket);
    RELEASE_OBJ(pTable);
    FreeProws(pRows);
    
    MAPIFreeBuffer(pEntryId);
    
    return hr;
}


////////////////////////////////////////////////////////////
// CountMessagesInFolder - takes a folder as argument and returns 
//  the # of messages in it
ULONG CountMessagesInFolder(LPMAPIFOLDER pFolder)
{
    hr = E_FAIL;
    IMAPIProp *pProp = NULL; 
    ULONG rgTags[] = {2, PR_CONTENT_COUNT, PR_FOLDER_TYPE};
    ULONG cValues = 0;
    SPropValue *rgFolderProps= NULL;

    // Get an IMAPIProp Interface
    hr = pFolder->QueryInterface(IID_IMAPIProp, (LPVOID *) &pProp);
    CHR(hr);
    CPR(pProp);

    // Get the Folder PR_CONTENT_COUNT property
    hr = pProp->GetProps((LPSPropTagArray)rgTags, MAPI_UNICODE, &cValues, &rgFolderProps);
    CHR(hr);
    CBR(PR_CONTENT_COUNT == rgFolderProps[0].ulPropTag);            
    CBR(PR_FOLDER_TYPE == rgFolderProps[1].ulPropTag);            
    
Error:
    // return the COUNT of messages in this folder
    return rgFolderProps[0].Value.ul;
}


////////////////////////////////////////////////////////////
// GetWastebasketForFolder
//  Independently on the currently selected folder, it returns 
//  the related Deleted Items folder
HRESULT GetWastebasketForFolder(LPMAPIFOLDER pFolder, LPMAPIFOLDER* ppfldrWastebasket)
{
    hr = E_FAIL;
    IMsgStore* pms = NULL;
    ULONG cItems;
    ULONG rgtagsFldr[] = { 1, PR_OWN_STORE_ENTRYID };
    ULONG rgtagsMsgStore[] = { 1, PR_IPM_WASTEBASKET_ENTRYID };
    LPSPropValue rgprops = NULL;

    // This method assumes that the CALLER already logged on to a MAPISession
    if (!m_pSession)
        CHR(E_FAIL);  

    // Now request the PR_OWN_STORE_ENTRYID on the folder.  This is the
    // ENTRYID of the message store that owns the folder object.
    hr = pFolder->GetProps((LPSPropTagArray)rgtagsFldr, MAPI_UNICODE, &cItems, &rgprops);
    CHR(hr);

    CBR(PR_OWN_STORE_ENTRYID == rgprops[0].ulPropTag);

    // Now open the message store object.
    hr = m_pSession->OpenEntry(rgprops[0].Value.bin.cb,
            (LPENTRYID)rgprops[0].Value.bin.lpb,
            NULL, 0, NULL, (LPUNKNOWN*)&pms);
    CHR(hr);

    MAPIFreeBuffer(rgprops);
    rgprops = NULL;

    // Get the ENTRYID of the wastebasket for the message store
    hr = pms->GetProps((LPSPropTagArray)rgtagsMsgStore, MAPI_UNICODE, &cItems, &rgprops);
    CHR(hr);

    // Now open the correct wastebasket and return it to the caller.
    CBR(PR_IPM_WASTEBASKET_ENTRYID == rgprops[0].ulPropTag);

    hr = m_pSession->OpenEntry(rgprops[0].Value.bin.cb,
            (LPENTRYID)rgprops[0].Value.bin.lpb,
            NULL, 0, NULL, (LPUNKNOWN*)ppfldrWastebasket);
    CHR(hr);

Error:
    MAPIFreeBuffer(rgprops);
    RELEASE_OBJ(pms);

    return hr;
}


////////////////////////////////////////////////////////////
// CreateEntryList
//  Needed because IMAPIFolder::DeleteMessages works on EntryLists
HRESULT CreateEntryList(SRowSet *pRows, ENTRYLIST **ppList)
{
    hr = E_FAIL;
    ENTRYLIST* plist = NULL;
    
    // How much space do we need to create this entry list?
    ULONG cbNeeded = sizeof(SBinaryArray) + (pRows->cRows * (sizeof(SBinary)));

    // Allocate one buffer to hold all the data for the list.
    hr = MAPIAllocateBuffer(cbNeeded, (LPVOID*)&plist);
    CHR(hr);
    CPR(plist);

    // Set the number of items in the EntryList 
    plist->cValues = pRows->cRows;

    // Set plist->lpbin to the place in the buffer where the array items will be
    // filled in
    BYTE* pb;
    pb = (BYTE*)plist;
    pb += sizeof(SBinaryArray);
    plist->lpbin = (SBinary*) pb;

    // Loop through the list setting the contents of the EntryList to the contents
    // of the incoming SRowSet
    for (int cItems = 0; cItems < (int)plist->cValues; cItems++)
    {
        plist->lpbin[cItems].cb = pRows->aRow[cItems].lpProps[0].Value.bin.cb;
        plist->lpbin[cItems].lpb = pRows->aRow[cItems].lpProps[0].Value.bin.lpb;

        // Track our memory usage 
        pb += sizeof(SBinary);
    }

    // Make sure that we didn't write off the end of our buffer...
    CBR(pb <= ((BYTE*)plist + cbNeeded));

Error:

    if (FAILED(hr))
    {
        MAPIFreeBuffer(plist);
        plist = NULL;
    }

    *ppList = plist;

    return hr;
}