| /* | |
| * SMTP Transport | |
| * | |
| * Copyright 2006 Robert Shearman for CodeWeavers | |
| * Copyright 2008 Hans Leidekker for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| * | |
| */ | |
| #define COBJMACROS | |
| #include <stdarg.h> | |
| #include <stdio.h> | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "winnt.h" | |
| #include "winuser.h" | |
| #include "objbase.h" | |
| #include "mimeole.h" | |
| #include "wine/debug.h" | |
| #include "inetcomm_private.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(inetcomm); | |
| typedef struct | |
| { | |
| InternetTransport InetTransport; | |
| ULONG refs; | |
| BOOL fESMTP; | |
| SMTPMESSAGE pending_message; | |
| INETADDR *addrlist; | |
| ULONG ulCurrentAddressIndex; | |
| } SMTPTransport; | |
| static HRESULT SMTPTransport_ParseResponse(SMTPTransport *This, char *pszResponse, SMTPRESPONSE *pResponse) | |
| { | |
| HRESULT hrServerError; | |
| TRACE("response: %s\n", debugstr_a(pszResponse)); | |
| if (!isdigit(*pszResponse)) | |
| return IXP_E_SMTP_RESPONSE_ERROR; | |
| pResponse->pTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2; | |
| pResponse->rIxpResult.pszResponse = pszResponse; | |
| pResponse->rIxpResult.dwSocketError = 0; | |
| pResponse->rIxpResult.uiServerError = strtol(pszResponse, &pszResponse, 10); | |
| pResponse->fDone = (*pszResponse != '-'); | |
| switch (pResponse->rIxpResult.uiServerError) | |
| { | |
| case 211: hrServerError = IXP_E_SMTP_211_SYSTEM_STATUS; break; | |
| case 214: hrServerError = IXP_E_SMTP_214_HELP_MESSAGE; break; | |
| case 220: hrServerError = IXP_E_SMTP_220_READY; break; | |
| case 221: hrServerError = IXP_E_SMTP_221_CLOSING; break; | |
| case 245: hrServerError = IXP_E_SMTP_245_AUTH_SUCCESS; break; | |
| case 250: hrServerError = IXP_E_SMTP_250_MAIL_ACTION_OKAY; break; | |
| case 251: hrServerError = IXP_E_SMTP_251_FORWARDING_MAIL; break; | |
| case 334: hrServerError = IXP_E_SMTP_334_AUTH_READY_RESPONSE; break; | |
| case 354: hrServerError = IXP_E_SMTP_354_START_MAIL_INPUT; break; | |
| case 421: hrServerError = IXP_E_SMTP_421_NOT_AVAILABLE; break; | |
| case 450: hrServerError = IXP_E_SMTP_450_MAILBOX_BUSY; break; | |
| case 451: hrServerError = IXP_E_SMTP_451_ERROR_PROCESSING; break; | |
| case 452: hrServerError = IXP_E_SMTP_452_NO_SYSTEM_STORAGE; break; | |
| case 454: hrServerError = IXP_E_SMTP_454_STARTTLS_FAILED; break; | |
| case 500: hrServerError = IXP_E_SMTP_500_SYNTAX_ERROR; break; | |
| case 501: hrServerError = IXP_E_SMTP_501_PARAM_SYNTAX; break; | |
| case 502: hrServerError = IXP_E_SMTP_502_COMMAND_NOTIMPL; break; | |
| case 503: hrServerError = IXP_E_SMTP_503_COMMAND_SEQ; break; | |
| case 504: hrServerError = IXP_E_SMTP_504_COMMAND_PARAM_NOTIMPL; break; | |
| case 530: hrServerError = IXP_E_SMTP_530_STARTTLS_REQUIRED; break; | |
| case 550: hrServerError = IXP_E_SMTP_550_MAILBOX_NOT_FOUND; break; | |
| case 551: hrServerError = IXP_E_SMTP_551_USER_NOT_LOCAL; break; | |
| case 552: hrServerError = IXP_E_SMTP_552_STORAGE_OVERFLOW; break; | |
| case 553: hrServerError = IXP_E_SMTP_553_MAILBOX_NAME_SYNTAX; break; | |
| case 554: hrServerError = IXP_E_SMTP_554_TRANSACT_FAILED; break; | |
| default: | |
| hrServerError = IXP_E_SMTP_RESPONSE_ERROR; | |
| break; | |
| } | |
| pResponse->rIxpResult.hrResult = hrServerError; | |
| pResponse->rIxpResult.hrServerError = hrServerError; | |
| if (This->InetTransport.pCallback && This->InetTransport.fCommandLogging) | |
| { | |
| ITransportCallback_OnCommand(This->InetTransport.pCallback, CMD_RESP, | |
| pResponse->rIxpResult.pszResponse, hrServerError, | |
| (IInternetTransport *)&This->InetTransport.u.vtbl); | |
| } | |
| return S_OK; | |
| } | |
| static void SMTPTransport_CallbackDoNothing(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| TRACE("\n"); | |
| } | |
| static void SMTPTransport_CallbackReadResponseDoNothing(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackDoNothing); | |
| } | |
| static void SMTPTransport_CallbackProcessDATAResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = SMTP_DATA; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| } | |
| static void SMTPTransport_CallbackReadDATAResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessDATAResponse); | |
| } | |
| static void SMTPTransport_CallbackProcessMAILResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = SMTP_MAIL; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| } | |
| static void SMTPTransport_CallbackReadMAILResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessMAILResponse); | |
| } | |
| static void SMTPTransport_CallbackProcessRCPTResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| HeapFree(GetProcessHeap(), 0, This->addrlist); | |
| This->addrlist = NULL; | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = SMTP_RCPT; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| } | |
| static void SMTPTransport_CallbackReadRCPTResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessRCPTResponse); | |
| } | |
| static void SMTPTransport_CallbackProcessHelloResp(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = This->fESMTP ? SMTP_EHLO : SMTP_HELO; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| if (!response.fDone) | |
| { | |
| InternetTransport_ReadLine(&This->InetTransport, | |
| SMTPTransport_CallbackProcessHelloResp); | |
| return; | |
| } | |
| /* FIXME: try to authorize */ | |
| /* always changed to this status, even if authorization not support on server */ | |
| InternetTransport_ChangeStatus(&This->InetTransport, IXP_AUTHORIZED); | |
| InternetTransport_ChangeStatus(&This->InetTransport, IXP_CONNECTED); | |
| memset(&response, 0, sizeof(response)); | |
| response.command = SMTP_CONNECTED; | |
| response.fDone = TRUE; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| } | |
| static void SMTPTransport_CallbackRecvHelloResp(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessHelloResp); | |
| } | |
| static void SMTPTransport_CallbackSendHello(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| const char *pszHello; | |
| char *pszCommand; | |
| const char szHostName[] = "localhost"; /* FIXME */ | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = SMTP_BANNER; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| TRACE("(%s)\n", pBuffer); | |
| This->fESMTP = strstr(response.rIxpResult.pszResponse, "ESMTP") && | |
| This->InetTransport.ServerInfo.dwFlags & (ISF_SSLONSAMEPORT|ISF_QUERYDSNSUPPORT|ISF_QUERYAUTHSUPPORT); | |
| if (This->fESMTP) | |
| pszHello = "EHLO "; | |
| else | |
| pszHello = "HELO "; | |
| pszCommand = HeapAlloc(GetProcessHeap(), 0, strlen(pszHello) + strlen(szHostName) + 2); | |
| strcpy(pszCommand, pszHello); | |
| strcat(pszCommand, szHostName); | |
| pszCommand[strlen(pszCommand)+1] = '\0'; | |
| pszCommand[strlen(pszCommand)] = '\n'; | |
| InternetTransport_DoCommand(&This->InetTransport, pszCommand, | |
| SMTPTransport_CallbackRecvHelloResp); | |
| HeapFree(GetProcessHeap(), 0, pszCommand); | |
| } | |
| static void SMTPTransport_CallbackDisconnect(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| if (pBuffer) | |
| { | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| } | |
| InternetTransport_DropConnection(&This->InetTransport); | |
| } | |
| static void SMTPTransport_CallbackMessageProcessResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response = { 0 }; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| response.command = SMTP_SEND_MESSAGE; | |
| response.rIxpResult.hrResult = S_OK; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| } | |
| static void SMTPTransport_CallbackMessageReadResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageProcessResponse); | |
| } | |
| static void SMTPTransport_CallbackMessageSendDOT(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| IStream_Release(This->pending_message.pstmMsg); | |
| InternetTransport_DoCommand(&This->InetTransport, "\n.\n", | |
| SMTPTransport_CallbackMessageReadResponse); | |
| } | |
| static void SMTPTransport_CallbackMessageSendDataStream(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response; | |
| HRESULT hr; | |
| char *pszBuffer; | |
| ULONG cbSize; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| pszBuffer = HeapAlloc(GetProcessHeap(), 0, This->pending_message.cbSize); | |
| hr = IStream_Read(This->pending_message.pstmMsg, pszBuffer, This->pending_message.cbSize, NULL); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| cbSize = This->pending_message.cbSize; | |
| /* FIXME: map "\n.\n" to "\n..\n", reallocate memory, update cbSize */ | |
| /* FIXME: properly stream the message rather than writing it all at once */ | |
| hr = InternetTransport_Write(&This->InetTransport, pszBuffer, cbSize, | |
| SMTPTransport_CallbackMessageSendDOT); | |
| HeapFree(GetProcessHeap(), 0, pszBuffer); | |
| } | |
| static void SMTPTransport_CallbackMessageReadDataResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendDataStream); | |
| } | |
| static void SMTPTransport_CallbackMessageSendTo(IInternetTransport *iface, char *pBuffer, int cbBuffer); | |
| static void SMTPTransport_CallbackMessageReadToResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendTo); | |
| } | |
| static void SMTPTransport_CallbackMessageSendTo(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| SMTPRESPONSE response; | |
| HRESULT hr; | |
| TRACE("\n"); | |
| hr = SMTPTransport_ParseResponse(This, pBuffer, &response); | |
| if (FAILED(hr)) | |
| { | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| if (FAILED(response.rIxpResult.hrServerError)) | |
| { | |
| ERR("server error: %s\n", debugstr_a(pBuffer)); | |
| /* FIXME: handle error */ | |
| return; | |
| } | |
| for (; This->ulCurrentAddressIndex < This->pending_message.rAddressList.cAddress; This->ulCurrentAddressIndex++) | |
| { | |
| TRACE("address[%d]: %s\n", This->ulCurrentAddressIndex, | |
| This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail); | |
| if ((This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].addrtype & ADDR_TOFROM_MASK) == ADDR_TO) | |
| { | |
| const char szCommandFormat[] = "RCPT TO: <%s>\n"; | |
| char *szCommand; | |
| int len = sizeof(szCommandFormat) - 2 /* "%s" */ + | |
| strlen(This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return; | |
| sprintf(szCommand, szCommandFormat, | |
| This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail); | |
| This->ulCurrentAddressIndex++; | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackMessageReadToResponse); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return; | |
| } | |
| } | |
| hr = InternetTransport_DoCommand(&This->InetTransport, "DATA\n", | |
| SMTPTransport_CallbackMessageReadDataResponse); | |
| } | |
| static void SMTPTransport_CallbackMessageReadFromResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("\n"); | |
| InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendTo); | |
| } | |
| static HRESULT WINAPI SMTPTransport_QueryInterface(ISMTPTransport2 *iface, REFIID riid, void **ppv) | |
| { | |
| TRACE("(%s, %p)\n", debugstr_guid(riid), ppv); | |
| if (IsEqualIID(riid, &IID_IUnknown) || | |
| IsEqualIID(riid, &IID_IInternetTransport) || | |
| IsEqualIID(riid, &IID_ISMTPTransport) || | |
| IsEqualIID(riid, &IID_ISMTPTransport2)) | |
| { | |
| *ppv = iface; | |
| ISMTPTransport2_AddRef(iface); | |
| return S_OK; | |
| } | |
| *ppv = NULL; | |
| FIXME("no interface for %s\n", debugstr_guid(riid)); | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI SMTPTransport_AddRef(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| return InterlockedIncrement((LONG *)&This->refs); | |
| } | |
| static ULONG WINAPI SMTPTransport_Release(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| ULONG refs = InterlockedDecrement((LONG *)&This->refs); | |
| if (!refs) | |
| { | |
| TRACE("destroying %p\n", This); | |
| if (This->InetTransport.Status != IXP_DISCONNECTED) | |
| InternetTransport_DropConnection(&This->InetTransport); | |
| if (This->InetTransport.pCallback) ITransportCallback_Release(This->InetTransport.pCallback); | |
| HeapFree(GetProcessHeap(), 0, This->addrlist); | |
| HeapFree(GetProcessHeap(), 0, This); | |
| } | |
| return refs; | |
| } | |
| static HRESULT WINAPI SMTPTransport_GetServerInfo(ISMTPTransport2 *iface, | |
| LPINETSERVER pInetServer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("(%p)\n", pInetServer); | |
| return InternetTransport_GetServerInfo(&This->InetTransport, pInetServer); | |
| } | |
| static IXPTYPE WINAPI SMTPTransport_GetIXPType(ISMTPTransport2 *iface) | |
| { | |
| TRACE("()\n"); | |
| return IXP_SMTP; | |
| } | |
| static HRESULT WINAPI SMTPTransport_IsState(ISMTPTransport2 *iface, | |
| IXPISSTATE isstate) | |
| { | |
| FIXME("(%d): stub\n", isstate); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_InetServerFromAccount( | |
| ISMTPTransport2 *iface, IImnAccount *pAccount, LPINETSERVER pInetServer) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("(%p, %p)\n", pAccount, pInetServer); | |
| return InternetTransport_InetServerFromAccount(&This->InetTransport, pAccount, pInetServer); | |
| } | |
| static HRESULT WINAPI SMTPTransport_Connect(ISMTPTransport2 *iface, | |
| LPINETSERVER pInetServer, boolean fAuthenticate, boolean fCommandLogging) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| HRESULT hr; | |
| TRACE("(%p, %s, %s)\n", pInetServer, fAuthenticate ? "TRUE" : "FALSE", fCommandLogging ? "TRUE" : "FALSE"); | |
| hr = InternetTransport_Connect(&This->InetTransport, pInetServer, fAuthenticate, fCommandLogging); | |
| if (FAILED(hr)) | |
| return hr; | |
| /* this starts the state machine, which continues in SMTPTransport_CallbackSendHELO */ | |
| return InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackSendHello); | |
| } | |
| static HRESULT WINAPI SMTPTransport_HandsOffCallback(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| return InternetTransport_HandsOffCallback(&This->InetTransport); | |
| } | |
| static HRESULT WINAPI SMTPTransport_Disconnect(ISMTPTransport2 *iface) | |
| { | |
| TRACE("()\n"); | |
| return ISMTPTransport2_CommandQUIT(iface); | |
| } | |
| static HRESULT WINAPI SMTPTransport_DropConnection(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| return InternetTransport_DropConnection(&This->InetTransport); | |
| } | |
| static HRESULT WINAPI SMTPTransport_GetStatus(ISMTPTransport2 *iface, | |
| IXPSTATUS *pCurrentStatus) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| return InternetTransport_GetStatus(&This->InetTransport, pCurrentStatus); | |
| } | |
| static HRESULT WINAPI SMTPTransport_InitNew(ISMTPTransport2 *iface, | |
| LPSTR pszLogFilePath, ISMTPCallback *pCallback) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("(%s, %p)\n", debugstr_a(pszLogFilePath), pCallback); | |
| if (!pCallback) | |
| return E_INVALIDARG; | |
| if (pszLogFilePath) | |
| FIXME("not using log file of %s, use Wine debug logging instead\n", | |
| debugstr_a(pszLogFilePath)); | |
| ISMTPCallback_AddRef(pCallback); | |
| This->InetTransport.pCallback = (ITransportCallback *)pCallback; | |
| This->InetTransport.fInitialised = TRUE; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI SMTPTransport_SendMessage(ISMTPTransport2 *iface, | |
| LPSMTPMESSAGE pMessage) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| ULONG i, size; | |
| LPSTR pszFromAddress = NULL; | |
| const char szCommandFormat[] = "MAIL FROM: <%s>\n"; | |
| char *szCommand; | |
| int len; | |
| HRESULT hr; | |
| TRACE("(%p)\n", pMessage); | |
| This->pending_message = *pMessage; | |
| IStream_AddRef(pMessage->pstmMsg); | |
| size = pMessage->rAddressList.cAddress * sizeof(INETADDR); | |
| This->addrlist = HeapAlloc(GetProcessHeap(), 0, size); | |
| if (!This->addrlist) | |
| return E_OUTOFMEMORY; | |
| memcpy(This->addrlist, pMessage->rAddressList.prgAddress, size); | |
| This->pending_message.rAddressList.prgAddress = This->addrlist; | |
| This->ulCurrentAddressIndex = 0; | |
| for (i = 0; i < pMessage->rAddressList.cAddress; i++) | |
| { | |
| if ((pMessage->rAddressList.prgAddress[i].addrtype & ADDR_TOFROM_MASK) == ADDR_FROM) | |
| { | |
| TRACE("address[%d]: ADDR_FROM, %s\n", i, | |
| pMessage->rAddressList.prgAddress[i].szEmail); | |
| pszFromAddress = pMessage->rAddressList.prgAddress[i].szEmail; | |
| } | |
| else if ((pMessage->rAddressList.prgAddress[i].addrtype & ADDR_TOFROM_MASK) == ADDR_TO) | |
| { | |
| TRACE("address[%d]: ADDR_TO, %s\n", i, | |
| pMessage->rAddressList.prgAddress[i].szEmail); | |
| } | |
| } | |
| if (!pszFromAddress) | |
| { | |
| SMTPRESPONSE response; | |
| memset(&response, 0, sizeof(response)); | |
| response.command = SMTP_SEND_MESSAGE; | |
| response.fDone = TRUE; | |
| response.pTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2; | |
| response.rIxpResult.hrResult = IXP_E_SMTP_NO_SENDER; | |
| ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response); | |
| return S_OK; | |
| } | |
| len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszFromAddress); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, pszFromAddress); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackMessageReadFromResponse); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandMAIL(ISMTPTransport2 *iface, LPSTR pszEmailFrom) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| const char szCommandFormat[] = "MAIL FROM: <%s>\n"; | |
| char *szCommand; | |
| int len; | |
| HRESULT hr; | |
| TRACE("(%s)\n", debugstr_a(pszEmailFrom)); | |
| if (!pszEmailFrom) | |
| return E_INVALIDARG; | |
| len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszEmailFrom); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, pszEmailFrom); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackReadMAILResponse); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandRCPT(ISMTPTransport2 *iface, LPSTR pszEmailTo) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| const char szCommandFormat[] = "RCPT TO: <%s>\n"; | |
| char *szCommand; | |
| int len; | |
| HRESULT hr; | |
| TRACE("(%s)\n", debugstr_a(pszEmailTo)); | |
| if (!pszEmailTo) | |
| return E_INVALIDARG; | |
| len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszEmailTo); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, pszEmailTo); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackReadRCPTResponse); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandEHLO(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| const char szCommandFormat[] = "EHLO %s\n"; | |
| const char szHostname[] = "localhost"; /* FIXME */ | |
| char *szCommand; | |
| int len = sizeof(szCommandFormat) - 2 /* "%s" */ + sizeof(szHostname); | |
| HRESULT hr; | |
| TRACE("\n"); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, szHostname); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackReadResponseDoNothing); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandHELO(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| const char szCommandFormat[] = "HELO %s\n"; | |
| const char szHostname[] = "localhost"; /* FIXME */ | |
| char *szCommand; | |
| int len = sizeof(szCommandFormat) - 2 /* "%s" */ + sizeof(szHostname); | |
| HRESULT hr; | |
| TRACE("()\n"); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, szHostname); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackReadResponseDoNothing); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandAUTH(ISMTPTransport2 *iface, | |
| LPSTR pszAuthType) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| const char szCommandFormat[] = "AUTH %s\n"; | |
| char *szCommand; | |
| int len; | |
| HRESULT hr; | |
| TRACE("(%s)\n", debugstr_a(pszAuthType)); | |
| if (!pszAuthType) | |
| return E_INVALIDARG; | |
| len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszAuthType); | |
| szCommand = HeapAlloc(GetProcessHeap(), 0, len); | |
| if (!szCommand) | |
| return E_OUTOFMEMORY; | |
| sprintf(szCommand, szCommandFormat, pszAuthType); | |
| hr = InternetTransport_DoCommand(&This->InetTransport, szCommand, | |
| SMTPTransport_CallbackReadResponseDoNothing); | |
| HeapFree(GetProcessHeap(), 0, szCommand); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandQUIT(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| InternetTransport_ChangeStatus(&This->InetTransport, IXP_DISCONNECTING); | |
| return InternetTransport_DoCommand(&This->InetTransport, "QUIT\n", | |
| SMTPTransport_CallbackDisconnect); | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandRSET(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| return InternetTransport_DoCommand(&This->InetTransport, "RSET\n", | |
| SMTPTransport_CallbackReadResponseDoNothing); | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandDATA(ISMTPTransport2 *iface) | |
| { | |
| SMTPTransport *This = (SMTPTransport *)iface; | |
| TRACE("()\n"); | |
| return InternetTransport_DoCommand(&This->InetTransport, "DATA\n", | |
| SMTPTransport_CallbackReadDATAResponse); | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandDOT(ISMTPTransport2 *iface) | |
| { | |
| FIXME("()\n"); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_SendDataStream(ISMTPTransport2 *iface, | |
| IStream *pStream, ULONG cbSize) | |
| { | |
| FIXME("(%p, %d)\n", pStream, cbSize); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_SetWindow(ISMTPTransport2 *iface) | |
| { | |
| FIXME("()\n"); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_ResetWindow(ISMTPTransport2 *iface) | |
| { | |
| FIXME("()\n"); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_SendMessage2(ISMTPTransport2 *iface, LPSMTPMESSAGE2 pMessage) | |
| { | |
| FIXME("(%p)\n", pMessage); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI SMTPTransport_CommandRCPT2(ISMTPTransport2 *iface, LPSTR pszEmailTo, | |
| INETADDRTYPE atDSN) | |
| { | |
| FIXME("(%s, %u)\n", pszEmailTo, atDSN); | |
| return E_NOTIMPL; | |
| } | |
| static const ISMTPTransport2Vtbl SMTPTransport2Vtbl = | |
| { | |
| SMTPTransport_QueryInterface, | |
| SMTPTransport_AddRef, | |
| SMTPTransport_Release, | |
| SMTPTransport_GetServerInfo, | |
| SMTPTransport_GetIXPType, | |
| SMTPTransport_IsState, | |
| SMTPTransport_InetServerFromAccount, | |
| SMTPTransport_Connect, | |
| SMTPTransport_HandsOffCallback, | |
| SMTPTransport_Disconnect, | |
| SMTPTransport_DropConnection, | |
| SMTPTransport_GetStatus, | |
| SMTPTransport_InitNew, | |
| SMTPTransport_SendMessage, | |
| SMTPTransport_CommandMAIL, | |
| SMTPTransport_CommandRCPT, | |
| SMTPTransport_CommandEHLO, | |
| SMTPTransport_CommandHELO, | |
| SMTPTransport_CommandAUTH, | |
| SMTPTransport_CommandQUIT, | |
| SMTPTransport_CommandRSET, | |
| SMTPTransport_CommandDATA, | |
| SMTPTransport_CommandDOT, | |
| SMTPTransport_SendDataStream, | |
| SMTPTransport_SetWindow, | |
| SMTPTransport_ResetWindow, | |
| SMTPTransport_SendMessage2, | |
| SMTPTransport_CommandRCPT2 | |
| }; | |
| HRESULT WINAPI CreateSMTPTransport(ISMTPTransport **ppTransport) | |
| { | |
| HRESULT hr; | |
| SMTPTransport *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); | |
| if (!This) | |
| return E_OUTOFMEMORY; | |
| This->InetTransport.u.vtblSMTP2 = &SMTPTransport2Vtbl; | |
| This->refs = 0; | |
| This->fESMTP = FALSE; | |
| hr = InternetTransport_Init(&This->InetTransport); | |
| if (FAILED(hr)) | |
| { | |
| HeapFree(GetProcessHeap(), 0, This); | |
| return hr; | |
| } | |
| *ppTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2; | |
| ISMTPTransport_AddRef(*ppTransport); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI SMTPTransportCF_QueryInterface(LPCLASSFACTORY iface, | |
| REFIID riid, LPVOID *ppv) | |
| { | |
| *ppv = NULL; | |
| if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory)) | |
| { | |
| *ppv = iface; | |
| IClassFactory_AddRef(iface); | |
| return S_OK; | |
| } | |
| return E_NOINTERFACE; | |
| } | |
| static ULONG WINAPI SMTPTransportCF_AddRef(LPCLASSFACTORY iface) | |
| { | |
| return 2; /* non-heap based object */ | |
| } | |
| static ULONG WINAPI SMTPTransportCF_Release(LPCLASSFACTORY iface) | |
| { | |
| return 1; /* non-heap based object */ | |
| } | |
| static HRESULT WINAPI SMTPTransportCF_CreateInstance(LPCLASSFACTORY iface, | |
| LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv) | |
| { | |
| HRESULT hr; | |
| ISMTPTransport *pSmtpTransport; | |
| TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv); | |
| *ppv = NULL; | |
| if (pUnk) | |
| return CLASS_E_NOAGGREGATION; | |
| hr = CreateSMTPTransport(&pSmtpTransport); | |
| if (FAILED(hr)) | |
| return hr; | |
| hr = ISMTPTransport_QueryInterface(pSmtpTransport, riid, ppv); | |
| ISMTPTransport_Release(pSmtpTransport); | |
| return hr; | |
| } | |
| static HRESULT WINAPI SMTPTransportCF_LockServer(LPCLASSFACTORY iface, BOOL fLock) | |
| { | |
| FIXME("(%d)\n",fLock); | |
| return S_OK; | |
| } | |
| static const IClassFactoryVtbl SMTPTransportCFVtbl = | |
| { | |
| SMTPTransportCF_QueryInterface, | |
| SMTPTransportCF_AddRef, | |
| SMTPTransportCF_Release, | |
| SMTPTransportCF_CreateInstance, | |
| SMTPTransportCF_LockServer | |
| }; | |
| static const IClassFactoryVtbl *SMTPTransportCF = &SMTPTransportCFVtbl; | |
| HRESULT SMTPTransportCF_Create(REFIID riid, LPVOID *ppv) | |
| { | |
| return IClassFactory_QueryInterface((IClassFactory *)&SMTPTransportCF, riid, ppv); | |
| } |