#include <mapix.h>
#include <mapiutil.h>
#include <mapi.h>
#include <atlbase.h>

#include <string>
#include <string.h>
#include <vector>
#include <fstream>
#include <assert.h>
//#include <stdlib.h>

#include <iostream>
#include <iomanip>

using namespace std;

#pragma warning( disable : 4127)

#define CORg(_hr) \
      do { \
            hr = _hr; \
            if (FAILED(hr)) \
            { \
                  std::wcout << L"FAILED! hr = " << std::hex << hr << L". LINE = " << std::dec << __LINE__ << std::endl; \
                  std::wcout << L" >>> " << (wchar_t*) L#_hr << std::endl; \
                  goto Error; \
            } \
      } while (0)

int ListStoresTable(IMAPISession *pSession)
{
      HRESULT hr = S_OK;
      CComPtr spTable;
      SRowSet *pmrows = NULL;

      enum MAPIColumns
      {
            COL_ENTRYID = 0,
            COL_DISPLAYNAME_W,
            COL_DISPLAYNAME_A,
            cCols // End marker
      };

      static const SizedSPropTagArray(cCols, mcols) =
      {
      cCols,
      {
            PR_ENTRYID,
                  PR_DISPLAY_NAME_W,
                  PR_DISPLAY_NAME_A,
      }
};

CORg(pSession->GetMsgStoresTable(0, ;spTable));

CORg(spTable->SetColumns((LPSPropTagArray);mcols, TBL_BATCH));
CORg(spTable->SeekRow(BOOKMARK_BEGINNING, 0, 0));

CORg(spTable->QueryRows(50, 0, ;pmrows));

std::wcout << L"Found " << pmrows->cRows << L" stores in MAPI profile:" << std::endl;
for (UINT i=0; i != pmrows->cRows; i++)
{
      SRow *prow = pmrows->aRow + i;
      LPCWSTR pwz = NULL;
      LPCSTR pwzA = NULL;
      if (PR_DISPLAY_NAME_W == prow->lpProps[COL_DISPLAYNAME_W].ulPropTag)
            pwz = prow->lpProps[COL_DISPLAYNAME_W].Value.lpszW;
      if (PR_DISPLAY_NAME_A == prow->lpProps[COL_DISPLAYNAME_A].ulPropTag)
            pwzA = prow->lpProps[COL_DISPLAYNAME_A].Value.lpszA;
      if (pwz)
            std::wcout << L" " << std::setw(4) << i << ": " << (pwz ? pwz : L"") << std::endl;
      else
            std::wcout << L" " << std::setw(4) << i << ": " << (pwzA ? pwzA : "") << std::endl;
      }

Error:
      FreeProws(pmrows);
      return 0;
}

int TestSimpleMapi(string reName, string reAddress, string subj, string body)
{
      MapiMessage msg = {0};
      MapiRecipDesc recip = {0};

      recip.ulRecipClass = MAPI_TO;
      recip.lpszName = (LPSTR)reName.c_str();
      recip.lpszAddress = (LPSTR)reAddress.c_str();

      msg.lpszSubject = (LPSTR)subj.c_str();
      msg.lpszNoteText = (LPSTR)body.c_str();
      msg.lpRecips = ;recip;
      msg.nRecipCount = 1;

      MAPISendMail(NULL, 0, ;msg, MAPI_LOGON_UI, 0);

      return 0;
}

void ForceOutlookMAPI(bool fForce);

int __cdecl main(int argc, char** argv)
{

      string fName = argv[1];

      HRESULT hr = S_OK;

      MAPIINIT_0 MAPIINIT= { 0, MAPI_MULTITHREAD_NOTIFICATIONS};

      ifstream fin(fName.c_str());

      vectortotalMessages;
      vector<string> names;
      vector<string> addresses;
      vector<string> subjects;
      vector<string> bodies;

      string s;
      while(getline(fin, s, '#')){
            if(s.length() > 3){
                  s+="#";
                  totalMessages.push_back(s);
            }
      }
            //cout << totalMessages.size() << "\n";
      int start, end;
      for(int j = 0; j < totalMessages.size(); j++){

            /*the name*/
            start = 0;
      end = 0;

            //email address
            start = totalMessages[j].find_first_of('>', 0);
            end = totalMessages[j].find_first_of('\n', start+1);
            addresses.push_back(totalMessages[j].substr(start+1, (end-start)));
            names.push_back(totalMessages[j].substr(start+1, end-start));

            //subject line
            start = end;
            end = totalMessages[j].find_first_of('\n', start+1);
            subjects.push_back(totalMessages[j].substr(start+1, end-start));

            //message body
            start = end;
            end = totalMessages[j].size();
            bodies.push_back(totalMessages[j].substr(start+1, end-start));
      }

      //trim newline characters.
      int endpos;
      for(int k = 0; k < addresses.size(); k++){
            endpos = addresses[k].find_last_not_of("\n");
            if(string::npos != endpos){
                  addresses[k] = addresses[k].substr(0,endpos+1);
            }
      }
      for(int k = 0; k < subjects.size(); k++){
            endpos = subjects[k].find_last_not_of("\n");
            if(string::npos != endpos){
                  subjects[k] = subjects[k].substr(0,endpos+1);
            }
      }

//ForceOutlookMAPI(true);

//assert(names.size() == addresses.size());
//assert(names.size() == subjects.size());
//assert(names.size() == bodies.size());
//assert(names.size() == totalMessages.size());

      string smtp = "SMTP:";

      for(int i = 0; i < names.size();i++){
            cout << totalMessages.size() - i <<"\n";
            TestSimpleMapi(names[i],smtp + addresses[i],subjects[i],bodies[i]);
      }

      CORg(MAPIInitialize (;MAPIINIT));

      { // IMAPISession Smart Pointer Context
            CComPtr spSession;
            CORg(MAPILogonEx(NULL, NULL, NULL, MAPI_UNICODE | MAPI_LOGON_UI, ;spSession));

            ListStoresTable(spSession);
      }

MAPIUninitialize();

Error:
      return 0;
}

The first thing you see is the #include list. There's only one item there that really merits attention, and that's atlbase.h. Atlbase.h is necessary for this file to work, since it works with the MAPI Stub Library; however, it's no longer included by Microsoft with the free version of Visual C++ (as of VC++ 2010 Express). It is included with the paid version, but we've already decided we're not paying for third-party software, so we're going to acquire it ourselves. The Microsoft Platform SDK for Server 2003 does come with atlbase.h, and it's available for download here. Once you download and install that, you have to find atlbase.h and move it into Visual Studio's include folder (C:\Program Files\Microsoft Visual Studio 10.0\VC\include\ if you used the standard directory path to install VC++ 2010 Express). I'd recommend moving everything in atlbase.h's folder in the Platform SDK install into this new directory, since VC++ usually wants to compile atlbase.h itself and atlbase.h depends on several other files there.

Next we have a definition; that's part of the example file that I used that came with the Mapi Stub Library so I haven't touched it, nor would I recommend that you do so.

After that comes the listStoresTable function, which I also recommend against messing with - I didn't.

After that comes the interesting part. The function testSimpleMapi is where the email is actually being sent. What I did was make it take parameters (it originally was just sending to a dummy email address) and use them to send the message. This allows the function calling testSimpleMapi to choose the values for the Name, Address, Subject, and Body fields of the email, basically allowing just about any email to be sent. It also expresses them as strings, which makes passing them much easier compared to the LPSTR that Mapi expects. LPSTR is essentially a special type of string that Mapi uses - for our purposes we don't need to know anything other than that the cast is required.

Then we've got the main function of the program. Since for my particular purpose I needed to run it from the command line on a text file that contained all the emails I wanted to send formatted a particular way, I create a ifstream to read in the file, then split it into strings based on my delimiter: the #. The vector formed by these strings is totalMessages. Next, I used the fact that the text file included all the email addresses as the first line following the end of the last message, and the subject after that. For your purposes this will probably be different, so don't be afraid to fiddle with the code in this section - much of it is specific to my particular set of circumstances. However, I chose to leave it in so that you could see what I did, and hopefully then you could modify it to your own ends. After making vectors for each field that I intended to pass, I trimmed newline characters off (since they had a tendency to keep cropping up). Then, I added "SMTP:" to each email address, because Mapi expects the email addresses to have the type of protocol, a colon, and then the actual address; example@example.com needs to be "SMPT:example@example.com" for Mapi to accept it as legitimate. If your email system is using a different protocol than SMTP, you'd put that in instead. After that, I just used a for-loop to send all the emails.

The last series of instructions in the main function are there to un-initialize Mapi, since it can't be left running. Don't mess with them!

Basically, that's how to send out a bunch of email using Mapi.