Send email with BlitzMax

If your looking for a Windows only solution, I used the following C code for a DBPro plugin :

// Internet.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "Internet.h"
#include "mapi.h"
#include "io.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}


// This is the constructor of a class that has been exported.
// see Internet.h for the class definition
DWORD sendEMailShort(char *emailAddress,
				char *emailName,
				 char *subject,
				 char *noteText)
{
	return (sendEMail(emailAddress,emailName,subject,noteText,NULL));
}

DWORD sendEMail(char *emailAddress,
				char *emailName,
				 char *subject,
				 char *noteText,
				 char *attachments)
{
char szFileName[MAX_PATH+1];
MapiFileDesc fileDesc[MAX_ATTACHMENTS];
HINSTANCE hMail;
ULONG (PASCAL *lpfnSendMail)(ULONG, ULONG, MapiMessage*, FLAGS, ULONG);
MapiRecipDesc rec;
MapiMessage message;
int nError;

	hMail=NULL;

	GetSystemDirectory(szFileName, sizeof(szFileName));
	strcat(szFileName, "\\MAPI32.DLL");
	if (_access(szFileName,00)!=0)
	{
		return (ERROR_MAPINOTFOUND);
	}

	if ((hMail=LoadLibrary("MAPI32.DLL"))==NULL)
	{
		FreeLibrary(hMail);
		return (ERROR_LOADDLL);
	}

	(FARPROC&) lpfnSendMail = GetProcAddress(hMail, "MAPISendMail");
	if (lpfnSendMail==NULL)
	{
		FreeLibrary(hMail);
		return (ERROR_SENDMAIL);
	}

	ZeroMemory(&message,sizeof(message));
	ZeroMemory(&rec,sizeof(rec));
	rec.ulRecipClass=MAPI_TO;
	rec.lpszName=(emailName==NULL ? "<<Enter EMail Address>>" : emailName);
	rec.lpszAddress=(emailAddress==NULL ? "<<Enter EMail Address>>" : emailAddress);

	message.nRecipCount=1;
	message.lpRecips=&rec;
	message.lpszSubject=subject;

	message.nFileCount=0;

	message.lpszNoteText=noteText;

	if (attachments)
	{
	register int pos,numAttach;
	char buffer[MAX_PATH+1];

		ZeroMemory(&fileDesc,sizeof(fileDesc));
		pos=0;
		numAttach=0;

		while (*(attachments+pos)!=(char) NULL && numAttach<MAX_ATTACHMENTS)
		{	
		register int index;

			ZeroMemory(&buffer,sizeof(buffer));
			index=0;

			while (*(attachments+pos)!=(char) '|' && 
				   *(attachments+pos)!=(char) NULL &&
	
				   index<sizeof(buffer)-1)
			{
				buffer[index]=(char) *(attachments+pos);
				index++;
				pos++;
			}

			pos++;
			if (strlen(buffer)>0 && access(buffer,00)==0)
			{
				fileDesc[numAttach].flFlags=0; // NOT an OLE object
				fileDesc[numAttach].nPosition=-1; //loop;
				fileDesc[numAttach].lpszPathName=(LPSTR) buffer;
				fileDesc[numAttach].lpszFileName=NULL;
				fileDesc[numAttach].lpFileType=NULL; // Let the system cope with the extension
				message.nFileCount++;
				numAttach++;
			}
		}
	}

	message.lpFiles=(message.nFileCount>0 ? (lpMapiFileDesc) fileDesc : NULL);

	nError=lpfnSendMail(0,(ULONG) NULL,&message,MAPI_LOGON_UI | MAPI_DIALOG,0);

	FreeLibrary(hMail);
	return (nError==SUCCESS_SUCCESS ? ERROR_SUCCESS : \
		    nError==MAPI_USER_ABORT ? ERROR_USERABORT : \
			nError==MAPI_E_LOGIN_FAILURE ? ERROR_LOGINFAILURE : \
			nError==MAPI_E_INSUFFICIENT_MEMORY ? ERROR_MEMERROR : \
			nError==MAPI_E_AMBIGUOUS_RECIPIENT ? ERROR_AMBIGRECIP : \
			nError==MAPI_E_ATTACHMENT_NOT_FOUND ? ERROR_FILENOTFOUND : \
			nError==MAPI_E_ATTACHMENT_OPEN_FAILURE ? ERROR_FILEOPEN : \
			nError==MAPI_E_BAD_RECIPTYPE ? ERROR_INVALIDPARAM : \
			nError==MAPI_E_FAILURE ? ERROR_UNKNOWN : \
			nError==MAPI_E_INVALID_RECIPS ? ERROR_INVALIDRECIP : \
			nError==MAPI_E_TEXT_TOO_LARGE ? ERROR_TEXTTOOLARGE : \
			nError==MAPI_E_TOO_MANY_FILES ? ERROR_TOOMANYFILES : \
			nError==MAPI_E_TOO_MANY_RECIPIENTS ? ERROR_TOOMANYRECIP : \
			nError==MAPI_E_UNKNOWN_RECIPIENT ? ERROR_UNKNOWNRECIP : ERROR_UNKNOWN);
}

It should be easy enough to convert to BlitzMax