dlls/inetcomm/smtptransport.c

   1 /*
   2  * SMTP Transport
   3  *
   4  * Copyright 2006 Robert Shearman for CodeWeavers
   5  * Copyright 2008 Hans Leidekker for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winnt.h"
  31 #include "winuser.h"
  32 #include "objbase.h"
  33 #include "mimeole.h"
  34 #include "wine/debug.h"
  35
  36 #include "inetcomm_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
  39
  40 typedef struct
  41 {
  42     InternetTransport InetTransport;
  43     ULONG refs;
  44     BOOL fESMTP;
  45     SMTPMESSAGE pending_message;
  46     INETADDR *addrlist;
  47     ULONG ulCurrentAddressIndex;
  48 } SMTPTransport;
  49
  50 static HRESULT SMTPTransport_ParseResponse(SMTPTransport *This, char *pszResponse, SMTPRESPONSE *pResponse)
  51 {
  52     HRESULT hrServerError;
  53
  54     TRACE("response: %s\n", debugstr_a(pszResponse));
  55
  56     if (!isdigit(*pszResponse))
  57         return IXP_E_SMTP_RESPONSE_ERROR;
  58     pResponse->pTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2;
  59     pResponse->rIxpResult.pszResponse = pszResponse;
  60     pResponse->rIxpResult.dwSocketError = 0;
  61     pResponse->rIxpResult.uiServerError = strtol(pszResponse, &pszResponse, 10);
  62     if (*pszResponse == '-')
  63     {
  64         pResponse->fDone = FALSE;
  65         pszResponse++;
  66     }
  67     else
  68         pResponse->fDone = TRUE;
  69
  70     switch (pResponse->rIxpResult.uiServerError)
  71     {
  72     case 211: hrServerError = IXP_E_SMTP_211_SYSTEM_STATUS; break;
  73     case 214: hrServerError = IXP_E_SMTP_214_HELP_MESSAGE; break;
  74     case 220: hrServerError = IXP_E_SMTP_220_READY; break;
  75     case 221: hrServerError = IXP_E_SMTP_221_CLOSING; break;
  76     case 245: hrServerError = IXP_E_SMTP_245_AUTH_SUCCESS; break;
  77     case 250: hrServerError = IXP_E_SMTP_250_MAIL_ACTION_OKAY; break;
  78     case 251: hrServerError = IXP_E_SMTP_251_FORWARDING_MAIL; break;
  79     case 334: hrServerError = IXP_E_SMTP_334_AUTH_READY_RESPONSE; break;
  80     case 354: hrServerError = IXP_E_SMTP_354_START_MAIL_INPUT; break;
  81     case 421: hrServerError = IXP_E_SMTP_421_NOT_AVAILABLE; break;
  82     case 450: hrServerError = IXP_E_SMTP_450_MAILBOX_BUSY; break;
  83     case 451: hrServerError = IXP_E_SMTP_451_ERROR_PROCESSING; break;
  84     case 452: hrServerError = IXP_E_SMTP_452_NO_SYSTEM_STORAGE; break;
  85     case 454: hrServerError = IXP_E_SMTP_454_STARTTLS_FAILED; break;
  86     case 500: hrServerError = IXP_E_SMTP_500_SYNTAX_ERROR; break;
  87     case 501: hrServerError = IXP_E_SMTP_501_PARAM_SYNTAX; break;
  88     case 502: hrServerError = IXP_E_SMTP_502_COMMAND_NOTIMPL; break;
  89     case 503: hrServerError = IXP_E_SMTP_503_COMMAND_SEQ; break;
  90     case 504: hrServerError = IXP_E_SMTP_504_COMMAND_PARAM_NOTIMPL; break;
  91     case 530: hrServerError = IXP_E_SMTP_530_STARTTLS_REQUIRED; break;
  92     case 550: hrServerError = IXP_E_SMTP_550_MAILBOX_NOT_FOUND; break;
  93     case 551: hrServerError = IXP_E_SMTP_551_USER_NOT_LOCAL; break;
  94     case 552: hrServerError = IXP_E_SMTP_552_STORAGE_OVERFLOW; break;
  95     case 553: hrServerError = IXP_E_SMTP_553_MAILBOX_NAME_SYNTAX; break;
  96     case 554: hrServerError = IXP_E_SMTP_554_TRANSACT_FAILED; break;
  97     default:
  98         hrServerError = IXP_E_SMTP_RESPONSE_ERROR;
  99         break;
 100     }
 101     pResponse->rIxpResult.hrResult = hrServerError;
 102     pResponse->rIxpResult.hrServerError = hrServerError;
 103
 104     if (This->InetTransport.pCallback && This->InetTransport.fCommandLogging)
 105     {
 106         ITransportCallback_OnCommand(This->InetTransport.pCallback, CMD_RESP,
 107             pResponse->rIxpResult.pszResponse, hrServerError,
 108             (IInternetTransport *)&This->InetTransport.u.vtbl);
 109     }
 110     return S_OK;
 111 }
 112
 113 static void SMTPTransport_CallbackDoNothing(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 114 {
 115     TRACE("\n");
 116 }
 117
 118 static void SMTPTransport_CallbackReadResponseDoNothing(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 119 {
 120     SMTPTransport *This = (SMTPTransport *)iface;
 121
 122     TRACE("\n");
 123     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackDoNothing);
 124 }
 125
 126 static void SMTPTransport_CallbackProcessDATAResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 127 {
 128     SMTPTransport *This = (SMTPTransport *)iface;
 129     SMTPRESPONSE response = { 0 };
 130     HRESULT hr;
 131
 132     TRACE("\n");
 133
 134     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 135     if (FAILED(hr))
 136     {
 137         /* FIXME: handle error */
 138         return;
 139     }
 140
 141     response.command = SMTP_DATA;
 142     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 143
 144     if (FAILED(response.rIxpResult.hrServerError))
 145     {
 146         ERR("server error: %s\n", debugstr_a(pBuffer));
 147         /* FIXME: handle error */
 148         return;
 149     }
 150 }
 151
 152 static void SMTPTransport_CallbackReadDATAResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 153 {
 154     SMTPTransport *This = (SMTPTransport *)iface;
 155
 156     TRACE("\n");
 157     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessDATAResponse);
 158 }
 159
 160 static void SMTPTransport_CallbackProcessMAILResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 161 {
 162     SMTPTransport *This = (SMTPTransport *)iface;
 163     SMTPRESPONSE response = { 0 };
 164     HRESULT hr;
 165
 166     TRACE("\n");
 167
 168     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 169     if (FAILED(hr))
 170     {
 171         /* FIXME: handle error */
 172         return;
 173     }
 174
 175     response.command = SMTP_MAIL;
 176     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 177
 178     if (FAILED(response.rIxpResult.hrServerError))
 179     {
 180         ERR("server error: %s\n", debugstr_a(pBuffer));
 181         /* FIXME: handle error */
 182         return;
 183     }
 184 }
 185
 186 static void SMTPTransport_CallbackReadMAILResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 187 {
 188     SMTPTransport *This = (SMTPTransport *)iface;
 189
 190     TRACE("\n");
 191     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessMAILResponse);
 192 }
 193
 194 static void SMTPTransport_CallbackProcessRCPTResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 195 {
 196     SMTPTransport *This = (SMTPTransport *)iface;
 197     SMTPRESPONSE response = { 0 };
 198     HRESULT hr;
 199
 200     TRACE("\n");
 201
 202     HeapFree(GetProcessHeap(), 0, This->addrlist);
 203     This->addrlist = NULL;
 204
 205     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 206     if (FAILED(hr))
 207     {
 208         /* FIXME: handle error */
 209         return;
 210     }
 211
 212     response.command = SMTP_RCPT;
 213     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 214
 215     if (FAILED(response.rIxpResult.hrServerError))
 216     {
 217         ERR("server error: %s\n", debugstr_a(pBuffer));
 218         /* FIXME: handle error */
 219         return;
 220     }
 221 }
 222
 223 static void SMTPTransport_CallbackReadRCPTResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 224 {
 225     SMTPTransport *This = (SMTPTransport *)iface;
 226
 227     TRACE("\n");
 228     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessRCPTResponse);
 229 }
 230
 231 static void SMTPTransport_CallbackProcessHelloResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 232 {
 233     SMTPTransport *This = (SMTPTransport *)iface;
 234     SMTPRESPONSE response = { 0 };
 235     HRESULT hr;
 236
 237     TRACE("\n");
 238
 239     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 240     if (FAILED(hr))
 241     {
 242         /* FIXME: handle error */
 243         return;
 244     }
 245
 246     response.command = This->fESMTP ? SMTP_EHLO : SMTP_HELO;
 247     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 248
 249     if (FAILED(response.rIxpResult.hrServerError))
 250     {
 251         ERR("server error: %s\n", debugstr_a(pBuffer));
 252         /* FIXME: handle error */
 253         return;
 254     }
 255
 256     if (!response.fDone)
 257     {
 258         InternetTransport_ReadLine(&This->InetTransport,
 259             SMTPTransport_CallbackProcessHelloResp);
 260         return;
 261     }
 262
 263     /* FIXME: try to authorize */
 264
 265     /* always changed to this status, even if authorization not support on server */
 266     InternetTransport_ChangeStatus(&This->InetTransport, IXP_AUTHORIZED);
 267     InternetTransport_ChangeStatus(&This->InetTransport, IXP_CONNECTED);
 268
 269     memset(&response, 0, sizeof(response));
 270     response.command = SMTP_CONNECTED;
 271     response.fDone = TRUE;
 272     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 273 }
 274
 275 static void SMTPTransport_CallbackRecvHelloResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 276 {
 277     SMTPTransport *This = (SMTPTransport *)iface;
 278
 279     TRACE("\n");
 280     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackProcessHelloResp);
 281 }
 282
 283 static void SMTPTransport_CallbackSendHello(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 284 {
 285     SMTPTransport *This = (SMTPTransport *)iface;
 286     SMTPRESPONSE response = { 0 };
 287     HRESULT hr;
 288     const char *pszHello;
 289     char *pszCommand;
 290     const char szHostName[] = "localhost"; /* FIXME */
 291
 292     TRACE("\n");
 293
 294     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 295     if (FAILED(hr))
 296     {
 297         /* FIXME: handle error */
 298         return;
 299     }
 300
 301     response.command = SMTP_BANNER;
 302     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 303
 304     if (FAILED(response.rIxpResult.hrServerError))
 305     {
 306         ERR("server error: %s\n", debugstr_a(pBuffer));
 307         /* FIXME: handle error */
 308         return;
 309     }
 310
 311     TRACE("(%s)\n", pBuffer);
 312
 313     This->fESMTP = strstr(response.rIxpResult.pszResponse, "ESMTP") &&
 314         This->InetTransport.ServerInfo.dwFlags & (ISF_SSLONSAMEPORT|ISF_QUERYDSNSUPPORT|ISF_QUERYAUTHSUPPORT);
 315
 316     if (This->fESMTP)
 317         pszHello = "EHLO ";
 318     else
 319         pszHello = "HELO ";
 320
 321     pszCommand = HeapAlloc(GetProcessHeap(), 0, strlen(pszHello) + strlen(szHostName) + 2);
 322     strcpy(pszCommand, pszHello);
 323     strcat(pszCommand, szHostName);
 324     pszCommand[strlen(pszCommand)+1] = '\0';
 325     pszCommand[strlen(pszCommand)] = '\n';
 326
 327     InternetTransport_DoCommand(&This->InetTransport, pszCommand,
 328         SMTPTransport_CallbackRecvHelloResp);
 329
 330     HeapFree(GetProcessHeap(), 0, pszCommand);
 331 }
 332
 333 static void SMTPTransport_CallbackDisconnect(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 334 {
 335     SMTPTransport *This = (SMTPTransport *)iface;
 336     SMTPRESPONSE response;
 337     HRESULT hr;
 338
 339     TRACE("\n");
 340
 341     if (pBuffer)
 342     {
 343         hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 344         if (FAILED(hr))
 345         {
 346             /* FIXME: handle error */
 347             return;
 348         }
 349
 350         if (FAILED(response.rIxpResult.hrServerError))
 351         {
 352             ERR("server error: %s\n", debugstr_a(pBuffer));
 353             /* FIXME: handle error */
 354             return;
 355         }
 356     }
 357     InternetTransport_DropConnection(&This->InetTransport);
 358 }
 359
 360 static void SMTPTransport_CallbackMessageProcessResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 361 {
 362     SMTPTransport *This = (SMTPTransport *)iface;
 363     SMTPRESPONSE response = { 0 };
 364     HRESULT hr;
 365
 366     TRACE("\n");
 367
 368     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 369     if (FAILED(hr))
 370     {
 371         /* FIXME: handle error */
 372         return;
 373     }
 374
 375     if (FAILED(response.rIxpResult.hrServerError))
 376     {
 377         ERR("server error: %s\n", debugstr_a(pBuffer));
 378         /* FIXME: handle error */
 379         return;
 380     }
 381
 382     response.command = SMTP_SEND_MESSAGE;
 383     response.rIxpResult.hrResult = S_OK;
 384     ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 385 }
 386
 387 static void SMTPTransport_CallbackMessageReadResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 388 {
 389     SMTPTransport *This = (SMTPTransport *)iface;
 390     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageProcessResponse);
 391 }
 392
 393 static void SMTPTransport_CallbackMessageSendDOT(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 394 {
 395     SMTPTransport *This = (SMTPTransport *)iface;
 396
 397     IStream_Release(This->pending_message.pstmMsg);
 398     InternetTransport_DoCommand(&This->InetTransport, "\n.\n",
 399         SMTPTransport_CallbackMessageReadResponse);
 400 }
 401
 402 static void SMTPTransport_CallbackMessageSendDataStream(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 403 {
 404     SMTPTransport *This = (SMTPTransport *)iface;
 405     SMTPRESPONSE response;
 406     HRESULT hr;
 407     char *pszBuffer;
 408     ULONG cbSize;
 409
 410     TRACE("\n");
 411
 412     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 413     if (FAILED(hr))
 414     {
 415         /* FIXME: handle error */
 416         return;
 417     }
 418
 419     if (FAILED(response.rIxpResult.hrServerError))
 420     {
 421         ERR("server error: %s\n", debugstr_a(pBuffer));
 422         /* FIXME: handle error */
 423         return;
 424     }
 425
 426     pszBuffer = HeapAlloc(GetProcessHeap(), 0, This->pending_message.cbSize);
 427     hr = IStream_Read(This->pending_message.pstmMsg, pszBuffer, This->pending_message.cbSize, NULL);
 428     if (FAILED(hr))
 429     {
 430         /* FIXME: handle error */
 431         return;
 432     }
 433     cbSize = This->pending_message.cbSize;
 434
 435     /* FIXME: map "\n.\n" to "\n..\n", reallocate memory, update cbSize */
 436
 437     /* FIXME: properly stream the message rather than writing it all at once */
 438
 439     hr = InternetTransport_Write(&This->InetTransport, pszBuffer, cbSize,
 440         SMTPTransport_CallbackMessageSendDOT);
 441
 442     HeapFree(GetProcessHeap(), 0, pszBuffer);
 443 }
 444
 445 static void SMTPTransport_CallbackMessageReadDataResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 446 {
 447     SMTPTransport *This = (SMTPTransport *)iface;
 448
 449     TRACE("\n");
 450     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendDataStream);
 451 }
 452
 453 static void SMTPTransport_CallbackMessageSendTo(IInternetTransport *iface, char *pBuffer, int cbBuffer);
 454
 455 static void SMTPTransport_CallbackMessageReadToResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 456 {
 457     SMTPTransport *This = (SMTPTransport *)iface;
 458
 459     TRACE("\n");
 460     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendTo);
 461 }
 462
 463 static void SMTPTransport_CallbackMessageSendTo(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 464 {
 465     SMTPTransport *This = (SMTPTransport *)iface;
 466     SMTPRESPONSE response;
 467     HRESULT hr;
 468
 469     TRACE("\n");
 470
 471     hr = SMTPTransport_ParseResponse(This, pBuffer, &response);
 472     if (FAILED(hr))
 473     {
 474         /* FIXME: handle error */
 475         return;
 476     }
 477
 478     if (FAILED(response.rIxpResult.hrServerError))
 479     {
 480         ERR("server error: %s\n", debugstr_a(pBuffer));
 481         /* FIXME: handle error */
 482         return;
 483     }
 484
 485     for (; This->ulCurrentAddressIndex < This->pending_message.rAddressList.cAddress; This->ulCurrentAddressIndex++)
 486     {
 487         TRACE("address[%d]: %s\n", This->ulCurrentAddressIndex,
 488             This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail);
 489
 490         if ((This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].addrtype & ADDR_TOFROM_MASK) == ADDR_TO)
 491         {
 492             const char szCommandFormat[] = "RCPT TO: <%s>\n";
 493             char *szCommand;
 494             int len = sizeof(szCommandFormat) - 2 /* "%s" */ +
 495                 strlen(This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail);
 496
 497             szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 498             if (!szCommand)
 499                 return;
 500
 501             sprintf(szCommand, szCommandFormat,
 502                 This->pending_message.rAddressList.prgAddress[This->ulCurrentAddressIndex].szEmail);
 503
 504             This->ulCurrentAddressIndex++;
 505             hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 506                 SMTPTransport_CallbackMessageReadToResponse);
 507
 508             HeapFree(GetProcessHeap(), 0, szCommand);
 509             return;
 510         }
 511     }
 512
 513     hr = InternetTransport_DoCommand(&This->InetTransport, "DATA\n",
 514         SMTPTransport_CallbackMessageReadDataResponse);
 515 }
 516
 517 static void SMTPTransport_CallbackMessageReadFromResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 518 {
 519     SMTPTransport *This = (SMTPTransport *)iface;
 520
 521     TRACE("\n");
 522     InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackMessageSendTo);
 523 }
 524
 525 static HRESULT WINAPI SMTPTransport_QueryInterface(ISMTPTransport2 *iface, REFIID riid, void **ppv)
 526 {
 527     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 528
 529     if (IsEqualIID(riid, &IID_IUnknown) ||
 530         IsEqualIID(riid, &IID_IInternetTransport) ||
 531         IsEqualIID(riid, &IID_ISMTPTransport) ||
 532         IsEqualIID(riid, &IID_ISMTPTransport2))
 533     {
 534         *ppv = iface;
 535         IUnknown_AddRef(iface);
 536         return S_OK;
 537     }
 538     *ppv = NULL;
 539     FIXME("no interface for %s\n", debugstr_guid(riid));
 540     return E_NOINTERFACE;
 541 }
 542
 543 static ULONG WINAPI SMTPTransport_AddRef(ISMTPTransport2 *iface)
 544 {
 545     SMTPTransport *This = (SMTPTransport *)iface;
 546     return InterlockedIncrement((LONG *)&This->refs);
 547 }
 548
 549 static ULONG WINAPI SMTPTransport_Release(ISMTPTransport2 *iface)
 550 {
 551     SMTPTransport *This = (SMTPTransport *)iface;
 552     ULONG refs = InterlockedDecrement((LONG *)&This->refs);
 553     if (!refs)
 554     {
 555         TRACE("destroying %p\n", This);
 556         if (This->InetTransport.Status != IXP_DISCONNECTED)
 557             InternetTransport_DropConnection(&This->InetTransport);
 558
 559         if (This->InetTransport.pCallback) ITransportCallback_Release(This->InetTransport.pCallback);
 560         HeapFree(GetProcessHeap(), 0, This->addrlist);
 561         HeapFree(GetProcessHeap(), 0, This);
 562     }
 563     return refs;
 564 }
 565
 566 static HRESULT WINAPI SMTPTransport_GetServerInfo(ISMTPTransport2 *iface,
 567     LPINETSERVER pInetServer)
 568 {
 569     SMTPTransport *This = (SMTPTransport *)iface;
 570
 571     TRACE("(%p)\n", pInetServer);
 572     return InternetTransport_GetServerInfo(&This->InetTransport, pInetServer);
 573 }
 574
 575 static IXPTYPE WINAPI SMTPTransport_GetIXPType(ISMTPTransport2 *iface)
 576 {
 577     TRACE("()\n");
 578     return IXP_SMTP;
 579 }
 580
 581 static HRESULT WINAPI SMTPTransport_IsState(ISMTPTransport2 *iface,
 582     IXPISSTATE isstate)
 583 {
 584     FIXME("(%d): stub\n", isstate);
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI SMTPTransport_InetServerFromAccount(
 589     ISMTPTransport2 *iface, IImnAccount *pAccount, LPINETSERVER pInetServer)
 590 {
 591     SMTPTransport *This = (SMTPTransport *)iface;
 592
 593     TRACE("(%p, %p)\n", pAccount, pInetServer);
 594     return InternetTransport_InetServerFromAccount(&This->InetTransport, pAccount, pInetServer);
 595 }
 596
 597 static HRESULT WINAPI SMTPTransport_Connect(ISMTPTransport2 *iface,
 598     LPINETSERVER pInetServer, boolean fAuthenticate, boolean fCommandLogging)
 599 {
 600     SMTPTransport *This = (SMTPTransport *)iface;
 601     HRESULT hr;
 602
 603     TRACE("(%p, %s, %s)\n", pInetServer, fAuthenticate ? "TRUE" : "FALSE", fCommandLogging ? "TRUE" : "FALSE");
 604
 605     hr = InternetTransport_Connect(&This->InetTransport, pInetServer, fAuthenticate, fCommandLogging);
 606     if (FAILED(hr))
 607         return hr;
 608
 609     /* this starts the state machine, which continues in SMTPTransport_CallbackSendHELO */
 610     return InternetTransport_ReadLine(&This->InetTransport, SMTPTransport_CallbackSendHello);
 611 }
 612
 613 static HRESULT WINAPI SMTPTransport_HandsOffCallback(ISMTPTransport2 *iface)
 614 {
 615     SMTPTransport *This = (SMTPTransport *)iface;
 616
 617     TRACE("()\n");
 618     return InternetTransport_HandsOffCallback(&This->InetTransport);
 619 }
 620
 621 static HRESULT WINAPI SMTPTransport_Disconnect(ISMTPTransport2 *iface)
 622 {
 623     TRACE("()\n");
 624     return ISMTPTransport2_CommandQUIT(iface);
 625 }
 626
 627 static HRESULT WINAPI SMTPTransport_DropConnection(ISMTPTransport2 *iface)
 628 {
 629     SMTPTransport *This = (SMTPTransport *)iface;
 630
 631     TRACE("()\n");
 632     return InternetTransport_DropConnection(&This->InetTransport);
 633 }
 634
 635 static HRESULT WINAPI SMTPTransport_GetStatus(ISMTPTransport2 *iface,
 636     IXPSTATUS *pCurrentStatus)
 637 {
 638     SMTPTransport *This = (SMTPTransport *)iface;
 639
 640     TRACE("()\n");
 641     return InternetTransport_GetStatus(&This->InetTransport, pCurrentStatus);
 642 }
 643
 644 static HRESULT WINAPI SMTPTransport_InitNew(ISMTPTransport2 *iface,
 645     LPSTR pszLogFilePath, ISMTPCallback *pCallback)
 646 {
 647     SMTPTransport *This = (SMTPTransport *)iface;
 648
 649     TRACE("(%s, %p)\n", debugstr_a(pszLogFilePath), pCallback);
 650
 651     if (!pCallback)
 652         return E_INVALIDARG;
 653
 654     if (pszLogFilePath)
 655         FIXME("not using log file of %s, use Wine debug logging instead\n",
 656             debugstr_a(pszLogFilePath));
 657
 658     ISMTPCallback_AddRef(pCallback);
 659     This->InetTransport.pCallback = (ITransportCallback *)pCallback;
 660     This->InetTransport.fInitialised = TRUE;
 661
 662     return S_OK;
 663 }
 664
 665 static HRESULT WINAPI SMTPTransport_SendMessage(ISMTPTransport2 *iface,
 666     LPSMTPMESSAGE pMessage)
 667 {
 668     SMTPTransport *This = (SMTPTransport *)iface;
 669     ULONG i, size;
 670     LPSTR pszFromAddress = NULL;
 671     const char szCommandFormat[] = "MAIL FROM: <%s>\n";
 672     char *szCommand;
 673     int len;
 674     HRESULT hr;
 675
 676     TRACE("(%p)\n", pMessage);
 677
 678     This->pending_message = *pMessage;
 679     IStream_AddRef(pMessage->pstmMsg);
 680
 681     size = pMessage->rAddressList.cAddress * sizeof(INETADDR);
 682     This->addrlist = HeapAlloc(GetProcessHeap(), 0, size);
 683     if (!This->addrlist)
 684         return E_OUTOFMEMORY;
 685
 686     memcpy(This->addrlist, pMessage->rAddressList.prgAddress, size);
 687     This->pending_message.rAddressList.prgAddress = This->addrlist;
 688     This->ulCurrentAddressIndex = 0;
 689
 690     for (i = 0; i < pMessage->rAddressList.cAddress; i++)
 691     {
 692         if ((pMessage->rAddressList.prgAddress[i].addrtype & ADDR_TOFROM_MASK) == ADDR_FROM)
 693         {
 694             TRACE("address[%d]: ADDR_FROM, %s\n", i,
 695                 pMessage->rAddressList.prgAddress[i].szEmail);
 696             pszFromAddress = pMessage->rAddressList.prgAddress[i].szEmail;
 697         }
 698         else if ((pMessage->rAddressList.prgAddress[i].addrtype & ADDR_TOFROM_MASK) == ADDR_TO)
 699         {
 700             TRACE("address[%d]: ADDR_TO, %s\n", i,
 701                 pMessage->rAddressList.prgAddress[i].szEmail);
 702         }
 703     }
 704
 705     if (!pszFromAddress)
 706     {
 707         SMTPRESPONSE response;
 708         memset(&response, 0, sizeof(response));
 709         response.command = SMTP_SEND_MESSAGE;
 710         response.fDone = TRUE;
 711         response.pTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2;
 712         response.rIxpResult.hrResult = IXP_E_SMTP_NO_SENDER;
 713         ISMTPCallback_OnResponse((ISMTPCallback *)This->InetTransport.pCallback, &response);
 714         return S_OK;
 715     }
 716     len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszFromAddress);
 717
 718     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 719     if (!szCommand)
 720         return E_OUTOFMEMORY;
 721
 722     sprintf(szCommand, szCommandFormat, pszFromAddress);
 723
 724     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 725         SMTPTransport_CallbackMessageReadFromResponse);
 726
 727     return hr;
 728 }
 729
 730 static HRESULT WINAPI SMTPTransport_CommandMAIL(ISMTPTransport2 *iface, LPSTR pszEmailFrom)
 731 {
 732     SMTPTransport *This = (SMTPTransport *)iface;
 733     const char szCommandFormat[] = "MAIL FROM: <%s>\n";
 734     char *szCommand;
 735     int len;
 736     HRESULT hr;
 737
 738     TRACE("(%s)\n", debugstr_a(pszEmailFrom));
 739
 740     if (!pszEmailFrom)
 741         return E_INVALIDARG;
 742
 743     len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszEmailFrom);
 744     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 745     if (!szCommand)
 746         return E_OUTOFMEMORY;
 747
 748     sprintf(szCommand, szCommandFormat, pszEmailFrom);
 749
 750     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 751         SMTPTransport_CallbackReadMAILResponse);
 752
 753     HeapFree(GetProcessHeap(), 0, szCommand);
 754     return hr;
 755 }
 756
 757 static HRESULT WINAPI SMTPTransport_CommandRCPT(ISMTPTransport2 *iface, LPSTR pszEmailTo)
 758 {
 759     SMTPTransport *This = (SMTPTransport *)iface;
 760     const char szCommandFormat[] = "RCPT TO: <%s>\n";
 761     char *szCommand;
 762     int len;
 763     HRESULT hr;
 764
 765     TRACE("(%s)\n", debugstr_a(pszEmailTo));
 766
 767     if (!pszEmailTo)
 768         return E_INVALIDARG;
 769
 770     len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszEmailTo);
 771     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 772     if (!szCommand)
 773         return E_OUTOFMEMORY;
 774
 775     sprintf(szCommand, szCommandFormat, pszEmailTo);
 776
 777     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 778         SMTPTransport_CallbackReadRCPTResponse);
 779
 780     HeapFree(GetProcessHeap(), 0, szCommand);
 781     return hr;
 782 }
 783
 784 static HRESULT WINAPI SMTPTransport_CommandEHLO(ISMTPTransport2 *iface)
 785 {
 786     SMTPTransport *This = (SMTPTransport *)iface;
 787     const char szCommandFormat[] = "EHLO %s\n";
 788     const char szHostname[] = "localhost"; /* FIXME */
 789     char *szCommand;
 790     int len = sizeof(szCommandFormat) - 2 /* "%s" */ + sizeof(szHostname);
 791     HRESULT hr;
 792
 793     TRACE("\n");
 794
 795     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 796     if (!szCommand)
 797         return E_OUTOFMEMORY;
 798
 799     sprintf(szCommand, szCommandFormat, szHostname);
 800
 801     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 802         SMTPTransport_CallbackReadResponseDoNothing);
 803
 804     HeapFree(GetProcessHeap(), 0, szCommand);
 805     return hr;
 806 }
 807
 808 static HRESULT WINAPI SMTPTransport_CommandHELO(ISMTPTransport2 *iface)
 809 {
 810     SMTPTransport *This = (SMTPTransport *)iface;
 811     const char szCommandFormat[] = "HELO %s\n";
 812     const char szHostname[] = "localhost"; /* FIXME */
 813     char *szCommand;
 814     int len = sizeof(szCommandFormat) - 2 /* "%s" */ + sizeof(szHostname);
 815     HRESULT hr;
 816
 817     TRACE("()\n");
 818
 819     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 820     if (!szCommand)
 821         return E_OUTOFMEMORY;
 822
 823     sprintf(szCommand, szCommandFormat, szHostname);
 824
 825     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 826         SMTPTransport_CallbackReadResponseDoNothing);
 827
 828     HeapFree(GetProcessHeap(), 0, szCommand);
 829     return hr;
 830 }
 831
 832 static HRESULT WINAPI SMTPTransport_CommandAUTH(ISMTPTransport2 *iface,
 833     LPSTR pszAuthType)
 834 {
 835     SMTPTransport *This = (SMTPTransport *)iface;
 836     const char szCommandFormat[] = "AUTH %s\n";
 837     char *szCommand;
 838     int len;
 839     HRESULT hr;
 840
 841     TRACE("(%s)\n", debugstr_a(pszAuthType));
 842
 843     if (!pszAuthType)
 844         return E_INVALIDARG;
 845
 846     len = sizeof(szCommandFormat) - 2 /* "%s" */ + strlen(pszAuthType);
 847     szCommand = HeapAlloc(GetProcessHeap(), 0, len);
 848     if (!szCommand)
 849         return E_OUTOFMEMORY;
 850
 851     sprintf(szCommand, szCommandFormat, pszAuthType);
 852
 853     hr = InternetTransport_DoCommand(&This->InetTransport, szCommand,
 854         SMTPTransport_CallbackReadResponseDoNothing);
 855
 856     HeapFree(GetProcessHeap(), 0, szCommand);
 857     return hr;
 858 }
 859
 860 static HRESULT WINAPI SMTPTransport_CommandQUIT(ISMTPTransport2 *iface)
 861 {
 862     SMTPTransport *This = (SMTPTransport *)iface;
 863
 864     TRACE("()\n");
 865
 866     InternetTransport_ChangeStatus(&This->InetTransport, IXP_DISCONNECTING);
 867     return InternetTransport_DoCommand(&This->InetTransport, "QUIT\n",
 868         SMTPTransport_CallbackDisconnect);
 869 }
 870
 871 static HRESULT WINAPI SMTPTransport_CommandRSET(ISMTPTransport2 *iface)
 872 {
 873     SMTPTransport *This = (SMTPTransport *)iface;
 874
 875     TRACE("()\n");
 876
 877     return InternetTransport_DoCommand(&This->InetTransport, "RSET\n",
 878         SMTPTransport_CallbackReadResponseDoNothing);
 879 }
 880
 881 static HRESULT WINAPI SMTPTransport_CommandDATA(ISMTPTransport2 *iface)
 882 {
 883     SMTPTransport *This = (SMTPTransport *)iface;
 884
 885     TRACE("()\n");
 886
 887     return InternetTransport_DoCommand(&This->InetTransport, "DATA\n",
 888         SMTPTransport_CallbackReadDATAResponse);
 889 }
 890
 891 static HRESULT WINAPI SMTPTransport_CommandDOT(ISMTPTransport2 *iface)
 892 {
 893     FIXME("()\n");
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI SMTPTransport_SendDataStream(ISMTPTransport2 *iface,
 898     IStream *pStream, ULONG cbSize)
 899 {
 900     FIXME("(%p, %d)\n", pStream, cbSize);
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI SMTPTransport_SetWindow(ISMTPTransport2 *iface)
 905 {
 906     FIXME("()\n");
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT WINAPI SMTPTransport_ResetWindow(ISMTPTransport2 *iface)
 911 {
 912     FIXME("()\n");
 913     return E_NOTIMPL;
 914 }
 915
 916 static HRESULT WINAPI SMTPTransport_SendMessage2(ISMTPTransport2 *iface, LPSMTPMESSAGE2 pMessage)
 917 {
 918     FIXME("(%p)\n", pMessage);
 919     return E_NOTIMPL;
 920 }
 921
 922 static HRESULT WINAPI SMTPTransport_CommandRCPT2(ISMTPTransport2 *iface, LPSTR pszEmailTo,
 923     INETADDRTYPE atDSN)
 924 {
 925     FIXME("(%s, %u)\n", pszEmailTo, atDSN);
 926     return E_NOTIMPL;
 927 }
 928
 929 static const ISMTPTransport2Vtbl SMTPTransport2Vtbl =
 930 {
 931     SMTPTransport_QueryInterface,
 932     SMTPTransport_AddRef,
 933     SMTPTransport_Release,
 934     SMTPTransport_GetServerInfo,
 935     SMTPTransport_GetIXPType,
 936     SMTPTransport_IsState,
 937     SMTPTransport_InetServerFromAccount,
 938     SMTPTransport_Connect,
 939     SMTPTransport_HandsOffCallback,
 940     SMTPTransport_Disconnect,
 941     SMTPTransport_DropConnection,
 942     SMTPTransport_GetStatus,
 943     SMTPTransport_InitNew,
 944     SMTPTransport_SendMessage,
 945     SMTPTransport_CommandMAIL,
 946     SMTPTransport_CommandRCPT,
 947     SMTPTransport_CommandEHLO,
 948     SMTPTransport_CommandHELO,
 949     SMTPTransport_CommandAUTH,
 950     SMTPTransport_CommandQUIT,
 951     SMTPTransport_CommandRSET,
 952     SMTPTransport_CommandDATA,
 953     SMTPTransport_CommandDOT,
 954     SMTPTransport_SendDataStream,
 955     SMTPTransport_SetWindow,
 956     SMTPTransport_ResetWindow,
 957     SMTPTransport_SendMessage2,
 958     SMTPTransport_CommandRCPT2
 959 };
 960
 961 HRESULT WINAPI CreateSMTPTransport(ISMTPTransport **ppTransport)
 962 {
 963     HRESULT hr;
 964     SMTPTransport *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 965     if (!This)
 966         return E_OUTOFMEMORY;
 967
 968     This->InetTransport.u.vtblSMTP2 = &SMTPTransport2Vtbl;
 969     This->refs = 0;
 970     This->fESMTP = FALSE;
 971     hr = InternetTransport_Init(&This->InetTransport);
 972     if (FAILED(hr))
 973     {
 974         HeapFree(GetProcessHeap(), 0, This);
 975         return hr;
 976     }
 977
 978     *ppTransport = (ISMTPTransport *)&This->InetTransport.u.vtblSMTP2;
 979     ISMTPTransport_AddRef(*ppTransport);
 980
 981     return S_OK;
 982 }
 983
 984
 985 static HRESULT WINAPI SMTPTransportCF_QueryInterface(LPCLASSFACTORY iface,
 986     REFIID riid, LPVOID *ppv)
 987 {
 988     *ppv = NULL;
 989     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
 990     {
 991         *ppv = iface;
 992         IUnknown_AddRef(iface);
 993         return S_OK;
 994     }
 995     return E_NOINTERFACE;
 996 }
 997
 998 static ULONG WINAPI SMTPTransportCF_AddRef(LPCLASSFACTORY iface)
 999 {
1000     return 2; /* non-heap based object */
1001 }
1002
1003 static ULONG WINAPI SMTPTransportCF_Release(LPCLASSFACTORY iface)
1004 {
1005     return 1; /* non-heap based object */
1006 }
1007
1008 static HRESULT WINAPI SMTPTransportCF_CreateInstance(LPCLASSFACTORY iface,
1009     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1010 {
1011     HRESULT hr;
1012     ISMTPTransport *pSmtpTransport;
1013
1014     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
1015
1016     *ppv = NULL;
1017
1018     if (pUnk)
1019         return CLASS_E_NOAGGREGATION;
1020
1021     hr = CreateSMTPTransport(&pSmtpTransport);
1022     if (FAILED(hr))
1023         return hr;
1024
1025     hr = ISMTPTransport_QueryInterface(pSmtpTransport, riid, ppv);
1026     ISMTPTransport_Release(pSmtpTransport);
1027
1028     return hr;
1029 }
1030
1031 static HRESULT WINAPI SMTPTransportCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1032 {
1033     FIXME("(%d)\n",fLock);
1034     return S_OK;
1035 }
1036
1037 static const IClassFactoryVtbl SMTPTransportCFVtbl =
1038 {
1039     SMTPTransportCF_QueryInterface,
1040     SMTPTransportCF_AddRef,
1041     SMTPTransportCF_Release,
1042     SMTPTransportCF_CreateInstance,
1043     SMTPTransportCF_LockServer
1044 };
1045 static const IClassFactoryVtbl *SMTPTransportCF = &SMTPTransportCFVtbl;
1046
1047 HRESULT SMTPTransportCF_Create(REFIID riid, LPVOID *ppv)
1048 {
1049     return IClassFactory_QueryInterface((IClassFactory *)&SMTPTransportCF, riid, ppv);
1050 }