dll/win32/inetcomm/pop3transport.c

   1 /*
   2  * POP3 Transport
   3  *
   4  * Copyright 2008 Hans Leidekker for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_NO_STATUS
  22 #define _INC_WINDOWS
  23 #define COM_NO_WINDOWS_H
  24
  25 #define COBJMACROS
  26 #define NONAMELESSUNION
  27
  28 //#include <stdarg.h>
  29 #include <stdio.h>
  30
  31 #include <windef.h>
  32 #include <winbase.h>
  33 //#include "winnt.h"
  34 //#include "winuser.h"
  35 #include <objbase.h>
  36 #include <mimeole.h>
  37 #include <wine/debug.h>
  38
  39 #include "inetcomm_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
  42
  43 enum parse_state
  44 {
  45     STATE_NONE,
  46     STATE_OK,
  47     STATE_MULTILINE,
  48     STATE_DONE
  49 };
  50
  51 typedef struct
  52 {
  53     InternetTransport InetTransport;
  54     ULONG refs;
  55     POP3COMMAND command;
  56     POP3CMDTYPE type;
  57     char *response;
  58     char *ptr;
  59     enum parse_state state;
  60     BOOL valid_info;
  61     DWORD msgid;
  62     DWORD preview_lines;
  63 } POP3Transport;
  64
  65 static HRESULT parse_response(POP3Transport *This)
  66 {
  67     switch (This->state)
  68     {
  69     case STATE_NONE:
  70         if (strlen(This->response) < 3)
  71         {
  72             WARN("parse error\n");
  73             This->state = STATE_DONE;
  74             return S_FALSE;
  75         }
  76         if (!memcmp(This->response, "+OK", 3))
  77         {
  78             This->ptr = This->response + 3;
  79             This->state = STATE_OK;
  80             return S_OK;
  81         }
  82         This->state = STATE_DONE;
  83         return S_FALSE;
  84
  85     default: return S_OK;
  86     }
  87 }
  88
  89 static HRESULT parse_uidl_response(POP3Transport *This, POP3UIDL *uidl)
  90 {
  91     char *p;
  92
  93     uidl->dwPopId = 0;
  94     uidl->pszUidl = NULL;
  95     switch (This->state)
  96     {
  97     case STATE_OK:
  98         if (This->type == POP3CMD_GET_POPID)
  99         {
 100             if ((p = strchr(This->ptr, ' ')))
 101             {
 102                 while (*p == ' ') p++;
 103                 sscanf(p, "%u", &uidl->dwPopId);
 104                 if ((p = strchr(p, ' ')))
 105                 {
 106                     while (*p == ' ') p++;
 107                     uidl->pszUidl = p;
 108                     This->valid_info = TRUE;
 109                 }
 110              }
 111              This->state = STATE_DONE;
 112              return S_OK;
 113         }
 114         This->state = STATE_MULTILINE;
 115         return S_OK;
 116
 117     case STATE_MULTILINE:
 118         if (This->response[0] == '.' && !This->response[1])
 119         {
 120             This->valid_info = FALSE;
 121             This->state = STATE_DONE;
 122             return S_OK;
 123         }
 124         sscanf(This->response, "%u", &uidl->dwPopId);
 125         if ((p = strchr(This->response, ' ')))
 126         {
 127             while (*p == ' ') p++;
 128             uidl->pszUidl = p;
 129             This->valid_info = TRUE;
 130             return S_OK;
 131         }
 132
 133     default:
 134         WARN("parse error\n");
 135         This->state = STATE_DONE;
 136         return S_FALSE;
 137     }
 138 }
 139
 140 static HRESULT parse_stat_response(POP3Transport *This, POP3STAT *stat)
 141 {
 142     char *p;
 143
 144     stat->cMessages = 0;
 145     stat->cbMessages = 0;
 146     switch (This->state)
 147     {
 148     case STATE_OK:
 149         if ((p = strchr(This->ptr, ' ')))
 150         {
 151             while (*p == ' ') p++;
 152             sscanf(p, "%u %u", &stat->cMessages, &stat->cbMessages);
 153             This->valid_info = TRUE;
 154             This->state = STATE_DONE;
 155             return S_OK;
 156         }
 157
 158     default:
 159         WARN("parse error\n");
 160         This->state = STATE_DONE;
 161         return S_FALSE;
 162     }
 163 }
 164
 165 static HRESULT parse_list_response(POP3Transport *This, POP3LIST *list)
 166 {
 167     char *p;
 168
 169     list->dwPopId = 0;
 170     list->cbSize = 0;
 171     switch (This->state)
 172     {
 173     case STATE_OK:
 174         if (This->type == POP3CMD_GET_POPID)
 175         {
 176             if ((p = strchr(This->ptr, ' ')))
 177             {
 178                 while (*p == ' ') p++;
 179                 sscanf(p, "%u %u", &list->dwPopId, &list->cbSize);
 180                 This->valid_info = TRUE;
 181             }
 182             This->state = STATE_DONE;
 183             return S_OK;
 184         }
 185         This->state = STATE_MULTILINE;
 186         return S_OK;
 187
 188     case STATE_MULTILINE:
 189         if (This->response[0] == '.' && !This->response[1])
 190         {
 191             This->valid_info = FALSE;
 192             This->state = STATE_DONE;
 193             return S_OK;
 194         }
 195         sscanf(This->response, "%u", &list->dwPopId);
 196         if ((p = strchr(This->response, ' ')))
 197         {
 198             while (*p == ' ') p++;
 199             sscanf(p, "%u", &list->cbSize);
 200             This->valid_info = TRUE;
 201             return S_OK;
 202         }
 203
 204     default:
 205         WARN("parse error\n");
 206         This->state = STATE_DONE;
 207         return S_FALSE;
 208     }
 209 }
 210
 211 static HRESULT parse_dele_response(POP3Transport *This, DWORD *dwPopId)
 212 {
 213     switch (This->state)
 214     {
 215     case STATE_OK:
 216         *dwPopId = 0; /* FIXME */
 217         This->state = STATE_DONE;
 218         return S_OK;
 219
 220     default:
 221         WARN("parse error\n");
 222         This->state = STATE_DONE;
 223         return S_FALSE;
 224     }
 225 }
 226
 227 static HRESULT parse_retr_response(POP3Transport *This, POP3RETR *retr)
 228 {
 229     switch (This->state)
 230     {
 231     case STATE_OK:
 232         retr->fHeader = FALSE;
 233         retr->fBody = FALSE;
 234         retr->dwPopId = This->msgid;
 235         retr->cbSoFar = 0;
 236         retr->pszLines = This->response;
 237         retr->cbLines = 0;
 238
 239         This->state = STATE_MULTILINE;
 240         This->valid_info = FALSE;
 241         return S_OK;
 242
 243     case STATE_MULTILINE:
 244     {
 245         int len;
 246
 247         if (This->response[0] == '.' && !This->response[1])
 248         {
 249             retr->cbLines = retr->cbSoFar;
 250             This->state = STATE_DONE;
 251             return S_OK;
 252         }
 253         retr->fHeader = TRUE;
 254         if (!This->response[0]) retr->fBody = TRUE;
 255
 256         len = strlen(This->response);
 257         retr->cbSoFar += len;
 258         retr->pszLines = This->response;
 259         retr->cbLines = len;
 260
 261         This->valid_info = TRUE;
 262         return S_OK;
 263     }
 264
 265     default:
 266         WARN("parse error\n");
 267         This->state = STATE_DONE;
 268         return S_FALSE;
 269     }
 270 }
 271
 272 static HRESULT parse_top_response(POP3Transport *This, POP3TOP *top)
 273 {
 274     switch (This->state)
 275     {
 276     case STATE_OK:
 277         top->fHeader = FALSE;
 278         top->fBody = FALSE;
 279         top->dwPopId = This->msgid;
 280         top->cPreviewLines = This->preview_lines;
 281         top->cbSoFar = 0;
 282         top->pszLines = This->response;
 283         top->cbLines = 0;
 284
 285         This->state = STATE_MULTILINE;
 286         This->valid_info = FALSE;
 287         return S_OK;
 288
 289     case STATE_MULTILINE:
 290     {
 291         int len;
 292
 293         if (This->response[0] == '.' && !This->response[1])
 294         {
 295             top->cbLines = top->cbSoFar;
 296             This->state = STATE_DONE;
 297             return S_OK;
 298         }
 299         top->fHeader = TRUE;
 300         if (!This->response[0]) top->fBody = TRUE;
 301
 302         len = strlen(This->response);
 303         top->cbSoFar += len;
 304         top->pszLines = This->response;
 305         top->cbLines = len;
 306
 307         This->valid_info = TRUE;
 308         return S_OK;
 309     }
 310
 311     default:
 312         WARN("parse error\n");
 313         This->state = STATE_DONE;
 314         return S_FALSE;
 315     }
 316 }
 317
 318 static void init_parser(POP3Transport *This, POP3COMMAND command, POP3CMDTYPE type)
 319 {
 320     This->state = STATE_NONE;
 321     This->command = command;
 322     This->type = type;
 323 }
 324
 325 static HRESULT POP3Transport_ParseResponse(POP3Transport *This, char *pszResponse, POP3RESPONSE *pResponse)
 326 {
 327     HRESULT hr;
 328
 329     TRACE("response: %s\n", debugstr_a(pszResponse));
 330
 331     This->response = pszResponse;
 332     This->valid_info = FALSE;
 333     TRACE("state %u\n", This->state);
 334
 335     if (SUCCEEDED((hr = parse_response(This))))
 336     {
 337         switch (This->command)
 338         {
 339         case POP3_UIDL: hr = parse_uidl_response(This, &pResponse->u.rUidlInfo); break;
 340         case POP3_STAT: hr = parse_stat_response(This, &pResponse->u.rStatInfo); break;
 341         case POP3_LIST: hr = parse_list_response(This, &pResponse->u.rListInfo); break;
 342         case POP3_DELE: hr = parse_dele_response(This, &pResponse->u.dwPopId); break;
 343         case POP3_RETR: hr = parse_retr_response(This, &pResponse->u.rRetrInfo); break;
 344         case POP3_TOP: hr = parse_top_response(This, &pResponse->u.rTopInfo); break;
 345         default:
 346             This->state = STATE_DONE;
 347             break;
 348         }
 349     }
 350     pResponse->command = This->command;
 351     pResponse->fDone = (This->state == STATE_DONE);
 352     pResponse->fValidInfo = This->valid_info;
 353     pResponse->rIxpResult.hrResult = hr;
 354     pResponse->rIxpResult.pszResponse = pszResponse;
 355     pResponse->rIxpResult.uiServerError = 0;
 356     pResponse->rIxpResult.hrServerError = pResponse->rIxpResult.hrResult;
 357     pResponse->rIxpResult.dwSocketError = WSAGetLastError();
 358     pResponse->rIxpResult.pszProblem = NULL;
 359     pResponse->pTransport = (IPOP3Transport *)&This->InetTransport.u.vtblPOP3;
 360
 361     if (This->InetTransport.pCallback && This->InetTransport.fCommandLogging)
 362     {
 363         ITransportCallback_OnCommand(This->InetTransport.pCallback, CMD_RESP,
 364             pResponse->rIxpResult.pszResponse, pResponse->rIxpResult.hrServerError,
 365             (IInternetTransport *)&This->InetTransport.u.vtbl);
 366     }
 367     return S_OK;
 368 }
 369
 370 static void POP3Transport_CallbackProcessDELEResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 371 {
 372     POP3Transport *This = (POP3Transport *)iface;
 373     POP3RESPONSE response;
 374     HRESULT hr;
 375
 376     TRACE("\n");
 377
 378     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 379     if (FAILED(hr))
 380     {
 381         /* FIXME: handle error */
 382         return;
 383     }
 384
 385     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 386 }
 387
 388 static void POP3Transport_CallbackRecvDELEResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 389 {
 390     POP3Transport *This = (POP3Transport *)iface;
 391
 392     TRACE("\n");
 393     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessDELEResp);
 394 }
 395
 396 static void POP3Transport_CallbackProcessNOOPResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 397 {
 398     POP3Transport *This = (POP3Transport *)iface;
 399     POP3RESPONSE response;
 400     HRESULT hr;
 401
 402     TRACE("\n");
 403
 404     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 405     if (FAILED(hr))
 406     {
 407         /* FIXME: handle error */
 408         return;
 409     }
 410
 411     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 412 }
 413
 414 static void POP3Transport_CallbackRecvNOOPResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 415 {
 416     POP3Transport *This = (POP3Transport *)iface;
 417
 418     TRACE("\n");
 419     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessNOOPResp);
 420 }
 421
 422 static void POP3Transport_CallbackProcessRSETResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 423 {
 424     POP3Transport *This = (POP3Transport *)iface;
 425     POP3RESPONSE response;
 426     HRESULT hr;
 427
 428     TRACE("\n");
 429
 430     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 431     if (FAILED(hr))
 432     {
 433         /* FIXME: handle error */
 434         return;
 435     }
 436
 437     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 438 }
 439
 440 static void POP3Transport_CallbackRecvRSETResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 441 {
 442     POP3Transport *This = (POP3Transport *)iface;
 443
 444     TRACE("\n");
 445     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessRSETResp);
 446 }
 447
 448 static void POP3Transport_CallbackProcessRETRResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 449 {
 450     POP3Transport *This = (POP3Transport *)iface;
 451     POP3RESPONSE response;
 452     HRESULT hr;
 453
 454     TRACE("\n");
 455
 456     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 457     if (FAILED(hr))
 458     {
 459         /* FIXME: handle error */
 460         return;
 461     }
 462
 463     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 464
 465     if (!response.fDone)
 466     {
 467         InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessRETRResp);
 468         return;
 469     }
 470
 471     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 472 }
 473
 474 static void POP3Transport_CallbackRecvRETRResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 475 {
 476     POP3Transport *This = (POP3Transport *)iface;
 477
 478     TRACE("\n");
 479     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessRETRResp);
 480 }
 481
 482 static void POP3Transport_CallbackProcessTOPResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 483 {
 484     POP3Transport *This = (POP3Transport *)iface;
 485     POP3RESPONSE response;
 486     HRESULT hr;
 487
 488     TRACE("\n");
 489
 490     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 491     if (FAILED(hr))
 492     {
 493         /* FIXME: handle error */
 494         return;
 495     }
 496
 497     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 498
 499     if (!response.fDone)
 500     {
 501         InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessTOPResp);
 502         return;
 503     }
 504
 505     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 506 }
 507
 508 static void POP3Transport_CallbackRecvTOPResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 509 {
 510     POP3Transport *This = (POP3Transport *)iface;
 511
 512     TRACE("\n");
 513     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessTOPResp);
 514 }
 515
 516 static void POP3Transport_CallbackProcessLISTResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 517 {
 518     POP3Transport *This = (POP3Transport *)iface;
 519     POP3RESPONSE response;
 520     HRESULT hr;
 521
 522     TRACE("\n");
 523
 524     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 525     if (FAILED(hr))
 526     {
 527         /* FIXME: handle error */
 528         return;
 529     }
 530
 531     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 532
 533     if (!response.fDone)
 534     {
 535         InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessLISTResp);
 536         return;
 537     }
 538
 539     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 540 }
 541
 542 static void POP3Transport_CallbackRecvLISTResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 543 {
 544     POP3Transport *This = (POP3Transport *)iface;
 545
 546     TRACE("\n");
 547     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessLISTResp);
 548 }
 549
 550 static void POP3Transport_CallbackProcessUIDLResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 551 {
 552     POP3Transport *This = (POP3Transport *)iface;
 553     POP3RESPONSE response;
 554     HRESULT hr;
 555
 556     TRACE("\n");
 557
 558     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 559     if (FAILED(hr))
 560     {
 561         /* FIXME: handle error */
 562         return;
 563     }
 564
 565     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 566
 567     if (!response.fDone)
 568     {
 569         InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessUIDLResp);
 570         return;
 571     }
 572
 573     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 574 }
 575
 576 static void POP3Transport_CallbackRecvUIDLResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 577 {
 578     POP3Transport *This = (POP3Transport *)iface;
 579
 580     TRACE("\n");
 581     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessUIDLResp);
 582 }
 583
 584 static void POP3Transport_CallbackProcessSTATResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 585 {
 586     POP3Transport *This = (POP3Transport *)iface;
 587     POP3RESPONSE response;
 588     HRESULT hr;
 589
 590     TRACE("\n");
 591
 592     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 593     if (FAILED(hr))
 594     {
 595         /* FIXME: handle error */
 596         return;
 597     }
 598
 599     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 600 }
 601
 602 static void POP3Transport_CallbackRecvSTATResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 603 {
 604     POP3Transport *This = (POP3Transport *)iface;
 605
 606     TRACE("\n");
 607     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessSTATResp);
 608 }
 609
 610 static void POP3Transport_CallbackProcessPASSResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 611 {
 612     POP3Transport *This = (POP3Transport *)iface;
 613     POP3RESPONSE response;
 614     HRESULT hr;
 615
 616     TRACE("\n");
 617
 618     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 619     if (FAILED(hr))
 620     {
 621         /* FIXME: handle error */
 622         return;
 623     }
 624
 625     InternetTransport_ChangeStatus(&This->InetTransport, IXP_AUTHORIZED);
 626     InternetTransport_ChangeStatus(&This->InetTransport, IXP_CONNECTED);
 627
 628     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 629 }
 630
 631 static void POP3Transport_CallbackRecvPASSResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 632 {
 633     POP3Transport *This = (POP3Transport *)iface;
 634
 635     TRACE("\n");
 636     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessPASSResp);
 637 }
 638
 639 static void POP3Transport_CallbackProcessUSERResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 640 {
 641     static char pass[] = "PASS ";
 642     POP3Transport *This = (POP3Transport *)iface;
 643     POP3RESPONSE response;
 644     char *command;
 645     int len;
 646     HRESULT hr;
 647
 648     TRACE("\n");
 649
 650     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 651     if (FAILED(hr))
 652     {
 653         /* FIXME: handle error */
 654         return;
 655     }
 656
 657     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 658
 659     len = sizeof(pass) + strlen(This->InetTransport.ServerInfo.szPassword) + 2; /* "\r\n" */
 660     command = HeapAlloc(GetProcessHeap(), 0, len);
 661
 662     strcpy(command, pass);
 663     strcat(command, This->InetTransport.ServerInfo.szPassword);
 664     strcat(command, "\r\n");
 665
 666     init_parser(This, POP3_PASS, POP3_NONE);
 667
 668     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvPASSResp);
 669     HeapFree(GetProcessHeap(), 0, command);
 670 }
 671
 672 static void POP3Transport_CallbackRecvUSERResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 673 {
 674     POP3Transport *This = (POP3Transport *)iface;
 675
 676     TRACE("\n");
 677     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessUSERResp);
 678 }
 679
 680 static void POP3Transport_CallbackSendUSERCmd(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 681 {
 682     static char user[] = "USER ";
 683     POP3Transport *This = (POP3Transport *)iface;
 684     char *command;
 685     int len;
 686
 687     TRACE("\n");
 688
 689     len = sizeof(user) + strlen(This->InetTransport.ServerInfo.szUserName) + 2; /* "\r\n" */
 690     command = HeapAlloc(GetProcessHeap(), 0, len);
 691
 692     strcpy(command, user);
 693     strcat(command, This->InetTransport.ServerInfo.szUserName);
 694     strcat(command, "\r\n");
 695     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvUSERResp);
 696
 697     HeapFree(GetProcessHeap(), 0, command);
 698 }
 699
 700 static void POP3Transport_CallbackProcessQUITResponse(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 701 {
 702     POP3Transport *This = (POP3Transport *)iface;
 703     POP3RESPONSE response;
 704     HRESULT hr;
 705
 706     TRACE("%s\n", debugstr_an(pBuffer, cbBuffer));
 707
 708     hr = POP3Transport_ParseResponse(This, pBuffer, &response);
 709     if (FAILED(hr))
 710     {
 711         /* FIXME: handle error */
 712         return;
 713     }
 714
 715     IPOP3Callback_OnResponse((IPOP3Callback *)This->InetTransport.pCallback, &response);
 716     InternetTransport_DropConnection(&This->InetTransport);
 717 }
 718
 719 static void POP3Transport_CallbackRecvQUITResp(IInternetTransport *iface, char *pBuffer, int cbBuffer)
 720 {
 721     POP3Transport *This = (POP3Transport *)iface;
 722
 723     TRACE("\n");
 724     InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackProcessQUITResponse);
 725 }
 726
 727 static HRESULT WINAPI POP3Transport_QueryInterface(IPOP3Transport *iface, REFIID riid, void **ppv)
 728 {
 729     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 730
 731     if (IsEqualIID(riid, &IID_IUnknown) ||
 732         IsEqualIID(riid, &IID_IInternetTransport) ||
 733         IsEqualIID(riid, &IID_IPOP3Transport))
 734     {
 735         *ppv = iface;
 736         IUnknown_AddRef(iface);
 737         return S_OK;
 738     }
 739     *ppv = NULL;
 740     FIXME("no interface for %s\n", debugstr_guid(riid));
 741     return E_NOINTERFACE;
 742 }
 743
 744 static ULONG WINAPI POP3Transport_AddRef(IPOP3Transport *iface)
 745 {
 746     POP3Transport *This = (POP3Transport *)iface;
 747     return InterlockedIncrement((LONG *)&This->refs);
 748 }
 749
 750 static ULONG WINAPI POP3Transport_Release(IPOP3Transport *iface)
 751 {
 752     POP3Transport *This = (POP3Transport *)iface;
 753     ULONG refs = InterlockedDecrement((LONG *)&This->refs);
 754     if (!refs)
 755     {
 756         TRACE("destroying %p\n", This);
 757         if (This->InetTransport.Status != IXP_DISCONNECTED)
 758             InternetTransport_DropConnection(&This->InetTransport);
 759         if (This->InetTransport.pCallback) ITransportCallback_Release(This->InetTransport.pCallback);
 760         HeapFree(GetProcessHeap(), 0, This);
 761     }
 762     return refs;
 763 }
 764
 765 static HRESULT WINAPI POP3Transport_GetServerInfo(IPOP3Transport *iface,
 766     LPINETSERVER pInetServer)
 767 {
 768     POP3Transport *This = (POP3Transport *)iface;
 769
 770     TRACE("(%p)\n", pInetServer);
 771     return InternetTransport_GetServerInfo(&This->InetTransport, pInetServer);
 772 }
 773
 774 static IXPTYPE WINAPI POP3Transport_GetIXPType(IPOP3Transport *iface)
 775 {
 776     TRACE("()\n");
 777     return IXP_POP3;
 778 }
 779
 780 static HRESULT WINAPI POP3Transport_IsState(IPOP3Transport *iface, IXPISSTATE isstate)
 781 {
 782     FIXME("(%u)\n", isstate);
 783     return E_NOTIMPL;
 784 }
 785
 786 static HRESULT WINAPI POP3Transport_InetServerFromAccount(
 787     IPOP3Transport *iface, IImnAccount *pAccount, LPINETSERVER pInetServer)
 788 {
 789     POP3Transport *This = (POP3Transport *)iface;
 790
 791     TRACE("(%p, %p)\n", pAccount, pInetServer);
 792     return InternetTransport_InetServerFromAccount(&This->InetTransport, pAccount, pInetServer);
 793 }
 794
 795 static HRESULT WINAPI POP3Transport_Connect(IPOP3Transport *iface,
 796     LPINETSERVER pInetServer, boolean fAuthenticate, boolean fCommandLogging)
 797 {
 798     POP3Transport *This = (POP3Transport *)iface;
 799     HRESULT hr;
 800
 801     TRACE("(%p, %s, %s)\n", pInetServer, fAuthenticate ? "TRUE" : "FALSE", fCommandLogging ? "TRUE" : "FALSE");
 802
 803     hr = InternetTransport_Connect(&This->InetTransport, pInetServer, fAuthenticate, fCommandLogging);
 804     if (FAILED(hr))
 805         return hr;
 806
 807     init_parser(This, POP3_USER, POP3_NONE);
 808     return InternetTransport_ReadLine(&This->InetTransport, POP3Transport_CallbackSendUSERCmd);
 809 }
 810
 811 static HRESULT WINAPI POP3Transport_HandsOffCallback(IPOP3Transport *iface)
 812 {
 813     POP3Transport *This = (POP3Transport *)iface;
 814
 815     TRACE("()\n");
 816     return InternetTransport_HandsOffCallback(&This->InetTransport);
 817 }
 818
 819 static HRESULT WINAPI POP3Transport_Disconnect(IPOP3Transport *iface)
 820 {
 821     TRACE("()\n");
 822     return IPOP3Transport_CommandQUIT(iface);
 823 }
 824
 825 static HRESULT WINAPI POP3Transport_DropConnection(IPOP3Transport *iface)
 826 {
 827     POP3Transport *This = (POP3Transport *)iface;
 828
 829     TRACE("()\n");
 830     return InternetTransport_DropConnection(&This->InetTransport);
 831 }
 832
 833 static HRESULT WINAPI POP3Transport_GetStatus(IPOP3Transport *iface,
 834     IXPSTATUS *pCurrentStatus)
 835 {
 836     POP3Transport *This = (POP3Transport *)iface;
 837
 838     TRACE("()\n");
 839     return InternetTransport_GetStatus(&This->InetTransport, pCurrentStatus);
 840 }
 841
 842 static HRESULT WINAPI POP3Transport_InitNew(IPOP3Transport *iface,
 843     LPSTR pszLogFilePath, IPOP3Callback *pCallback)
 844 {
 845     POP3Transport *This = (POP3Transport *)iface;
 846
 847     TRACE("(%s, %p)\n", debugstr_a(pszLogFilePath), pCallback);
 848
 849     if (!pCallback)
 850         return E_INVALIDARG;
 851
 852     if (pszLogFilePath)
 853         FIXME("not using log file of %s, use Wine debug logging instead\n",
 854             debugstr_a(pszLogFilePath));
 855
 856     IPOP3Callback_AddRef(pCallback);
 857     This->InetTransport.pCallback = (ITransportCallback *)pCallback;
 858     This->InetTransport.fInitialised = TRUE;
 859
 860     return S_OK;
 861 }
 862
 863 static HRESULT WINAPI POP3Transport_MarkItem(IPOP3Transport *iface, POP3MARKTYPE marktype,
 864     DWORD dwPopId, boolean fMarked)
 865 {
 866     FIXME("(%u, %u, %d)\n", marktype, dwPopId, fMarked);
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI POP3Transport_CommandAUTH(IPOP3Transport *iface, LPSTR pszAuthType)
 871 {
 872     FIXME("(%s)\n", pszAuthType);
 873     return E_NOTIMPL;
 874 }
 875
 876 static HRESULT WINAPI POP3Transport_CommandUSER(IPOP3Transport *iface, LPSTR username)
 877 {
 878     static char user[] = "USER ";
 879     POP3Transport *This = (POP3Transport *)iface;
 880     char *command;
 881     int len;
 882
 883     TRACE("(%s)\n", username);
 884
 885     len = sizeof(user) + strlen(username) + 2; /* "\r\n" */
 886     if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
 887
 888     strcpy(command, user);
 889     strcat(command, username);
 890     strcat(command, "\r\n");
 891
 892     init_parser(This, POP3_USER, POP3_NONE);
 893     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvUSERResp);
 894
 895     HeapFree(GetProcessHeap(), 0, command);
 896     return S_OK;
 897 }
 898
 899 static HRESULT WINAPI POP3Transport_CommandPASS(IPOP3Transport *iface, LPSTR password)
 900 {
 901     static char pass[] = "PASS ";
 902     POP3Transport *This = (POP3Transport *)iface;
 903     char *command;
 904     int len;
 905
 906     TRACE("(%p)\n", password);
 907
 908     len = sizeof(pass) + strlen(password) + 2; /* "\r\n" */
 909     if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
 910
 911     strcpy(command, pass);
 912     strcat(command, password);
 913     strcat(command, "\r\n");
 914
 915     init_parser(This, POP3_PASS, POP3_NONE);
 916     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvPASSResp);
 917
 918     HeapFree(GetProcessHeap(), 0, command);
 919     return S_OK;
 920 }
 921
 922 static HRESULT WINAPI POP3Transport_CommandLIST(
 923     IPOP3Transport *iface, POP3CMDTYPE cmdtype, DWORD dwPopId)
 924 {
 925     static char list[] = "LIST %u\r\n";
 926     static char list_all[] = "LIST\r\n";
 927     POP3Transport *This = (POP3Transport *)iface;
 928     char *command;
 929     int len;
 930
 931     TRACE("(%u, %u)\n", cmdtype, dwPopId);
 932
 933     if (dwPopId)
 934     {
 935         len = sizeof(list) + 10 + 2; /* "4294967296" + "\r\n" */
 936         if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
 937         sprintf(command, list, dwPopId);
 938     }
 939     else command = list_all;
 940
 941     init_parser(This, POP3_LIST, cmdtype);
 942     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvLISTResp);
 943
 944     if (dwPopId) HeapFree(GetProcessHeap(), 0, command);
 945     return S_OK;
 946 }
 947
 948 static HRESULT WINAPI POP3Transport_CommandTOP(
 949     IPOP3Transport *iface, POP3CMDTYPE cmdtype, DWORD dwPopId, DWORD cPreviewLines)
 950 {
 951     static char top[] = "TOP %u %u\r\n";
 952     POP3Transport *This = (POP3Transport *)iface;
 953     char *command;
 954     int len;
 955
 956     TRACE("(%u, %u, %u)\n", cmdtype, dwPopId, cPreviewLines);
 957
 958     len = sizeof(top) + 20 + 2; /* 2 * "4294967296" + "\r\n" */
 959     if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
 960     sprintf(command, top, dwPopId, cPreviewLines);
 961
 962     This->preview_lines = cPreviewLines;
 963     init_parser(This, POP3_TOP, cmdtype);
 964     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvTOPResp);
 965
 966     HeapFree(GetProcessHeap(), 0, command);
 967     return S_OK;
 968 }
 969
 970 static HRESULT WINAPI POP3Transport_CommandQUIT(IPOP3Transport *iface)
 971 {
 972     static char command[] = "QUIT\r\n";
 973     POP3Transport *This = (POP3Transport *)iface;
 974
 975     TRACE("()\n");
 976
 977     InternetTransport_ChangeStatus(&This->InetTransport, IXP_DISCONNECTING);
 978
 979     init_parser(This, POP3_QUIT, POP3_NONE);
 980     return InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvQUITResp);
 981 }
 982
 983 static HRESULT WINAPI POP3Transport_CommandSTAT(IPOP3Transport *iface)
 984 {
 985     static char stat[] = "STAT\r\n";
 986     POP3Transport *This = (POP3Transport *)iface;
 987
 988     TRACE("\n");
 989
 990     init_parser(This, POP3_STAT, POP3_NONE);
 991     InternetTransport_DoCommand(&This->InetTransport, stat, POP3Transport_CallbackRecvSTATResp);
 992     return S_OK;
 993 }
 994
 995 static HRESULT WINAPI POP3Transport_CommandNOOP(IPOP3Transport *iface)
 996 {
 997     static char noop[] = "NOOP\r\n";
 998     POP3Transport *This = (POP3Transport *)iface;
 999
1000     TRACE("\n");
1001
1002     init_parser(This, POP3_NOOP, POP3_NONE);
1003     InternetTransport_DoCommand(&This->InetTransport, noop, POP3Transport_CallbackRecvNOOPResp);
1004     return S_OK;
1005 }
1006
1007 static HRESULT WINAPI POP3Transport_CommandRSET(IPOP3Transport *iface)
1008 {
1009     static char rset[] = "RSET\r\n";
1010     POP3Transport *This = (POP3Transport *)iface;
1011
1012     TRACE("\n");
1013
1014     init_parser(This, POP3_RSET, POP3_NONE);
1015     InternetTransport_DoCommand(&This->InetTransport, rset, POP3Transport_CallbackRecvRSETResp);
1016     return S_OK;
1017 }
1018
1019 static HRESULT WINAPI POP3Transport_CommandUIDL(
1020     IPOP3Transport *iface, POP3CMDTYPE cmdtype, DWORD dwPopId)
1021 {
1022     static char uidl[] = "UIDL %u\r\n";
1023     static char uidl_all[] = "UIDL\r\n";
1024     POP3Transport *This = (POP3Transport *)iface;
1025     char *command;
1026     int len;
1027
1028     TRACE("(%u, %u)\n", cmdtype, dwPopId);
1029
1030     if (dwPopId)
1031     {
1032         len = sizeof(uidl) + 10 + 2; /* "4294967296" + "\r\n" */
1033         if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
1034         sprintf(command, uidl, dwPopId);
1035     }
1036     else command = uidl_all;
1037
1038     init_parser(This, POP3_UIDL, cmdtype);
1039     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvUIDLResp);
1040
1041     if (dwPopId) HeapFree(GetProcessHeap(), 0, command);
1042     return S_OK;
1043 }
1044
1045 static HRESULT WINAPI POP3Transport_CommandDELE(
1046     IPOP3Transport *iface, POP3CMDTYPE cmdtype, DWORD dwPopId)
1047 {
1048     static char dele[] = "DELE %u\r\n";
1049     POP3Transport *This = (POP3Transport *)iface;
1050     char *command;
1051     int len;
1052
1053     TRACE("(%u, %u)\n", cmdtype, dwPopId);
1054
1055     len = sizeof(dele) + 10 + 2; /* "4294967296" + "\r\n" */
1056     if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
1057     sprintf(command, dele, dwPopId);
1058
1059     init_parser(This, POP3_DELE, cmdtype);
1060     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvDELEResp);
1061
1062     HeapFree(GetProcessHeap(), 0, command);
1063     return S_OK;
1064 }
1065
1066 static HRESULT WINAPI POP3Transport_CommandRETR(
1067     IPOP3Transport *iface, POP3CMDTYPE cmdtype, DWORD dwPopId)
1068 {
1069     static char retr[] = "RETR %u\r\n";
1070     POP3Transport *This = (POP3Transport *)iface;
1071     char *command;
1072     int len;
1073
1074     TRACE("(%u, %u)\n", cmdtype, dwPopId);
1075
1076     len = sizeof(retr) + 10 + 2; /* "4294967296" + "\r\n" */
1077     if (!(command = HeapAlloc(GetProcessHeap(), 0, len))) return S_FALSE;
1078     sprintf(command, retr, dwPopId);
1079
1080     init_parser(This, POP3_RETR, cmdtype);
1081     InternetTransport_DoCommand(&This->InetTransport, command, POP3Transport_CallbackRecvRETRResp);
1082
1083     HeapFree(GetProcessHeap(), 0, command);
1084     return S_OK;
1085 }
1086
1087 static const IPOP3TransportVtbl POP3TransportVtbl =
1088 {
1089     POP3Transport_QueryInterface,
1090     POP3Transport_AddRef,
1091     POP3Transport_Release,
1092     POP3Transport_GetServerInfo,
1093     POP3Transport_GetIXPType,
1094     POP3Transport_IsState,
1095     POP3Transport_InetServerFromAccount,
1096     POP3Transport_Connect,
1097     POP3Transport_HandsOffCallback,
1098     POP3Transport_Disconnect,
1099     POP3Transport_DropConnection,
1100     POP3Transport_GetStatus,
1101     POP3Transport_InitNew,
1102     POP3Transport_MarkItem,
1103     POP3Transport_CommandAUTH,
1104     POP3Transport_CommandUSER,
1105     POP3Transport_CommandPASS,
1106     POP3Transport_CommandLIST,
1107     POP3Transport_CommandTOP,
1108     POP3Transport_CommandQUIT,
1109     POP3Transport_CommandSTAT,
1110     POP3Transport_CommandNOOP,
1111     POP3Transport_CommandRSET,
1112     POP3Transport_CommandUIDL,
1113     POP3Transport_CommandDELE,
1114     POP3Transport_CommandRETR
1115 };
1116
1117 HRESULT WINAPI CreatePOP3Transport(IPOP3Transport **ppTransport)
1118 {
1119     HRESULT hr;
1120     POP3Transport *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1121     if (!This)
1122         return E_OUTOFMEMORY;
1123
1124     This->InetTransport.u.vtblPOP3 = &POP3TransportVtbl;
1125     This->refs = 0;
1126     hr = InternetTransport_Init(&This->InetTransport);
1127     if (FAILED(hr))
1128     {
1129         HeapFree(GetProcessHeap(), 0, This);
1130         return hr;
1131     }
1132
1133     *ppTransport = (IPOP3Transport *)&This->InetTransport.u.vtblPOP3;
1134     IPOP3Transport_AddRef(*ppTransport);
1135
1136     return S_OK;
1137 }
1138
1139 static HRESULT WINAPI POP3TransportCF_QueryInterface(LPCLASSFACTORY iface,
1140     REFIID riid, LPVOID *ppv)
1141 {
1142     *ppv = NULL;
1143     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1144     {
1145         *ppv = iface;
1146         IUnknown_AddRef(iface);
1147         return S_OK;
1148     }
1149     return E_NOINTERFACE;
1150 }
1151
1152 static ULONG WINAPI POP3TransportCF_AddRef(LPCLASSFACTORY iface)
1153 {
1154     return 2; /* non-heap based object */
1155 }
1156
1157 static ULONG WINAPI POP3TransportCF_Release(LPCLASSFACTORY iface)
1158 {
1159     return 1; /* non-heap based object */
1160 }
1161
1162 static HRESULT WINAPI POP3TransportCF_CreateInstance(LPCLASSFACTORY iface,
1163     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1164 {
1165     HRESULT hr;
1166     IPOP3Transport *pPop3Transport;
1167
1168     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
1169
1170     *ppv = NULL;
1171
1172     if (pUnk)
1173         return CLASS_E_NOAGGREGATION;
1174
1175     hr = CreatePOP3Transport(&pPop3Transport);
1176     if (FAILED(hr))
1177         return hr;
1178
1179     hr = IPOP3Transport_QueryInterface(pPop3Transport, riid, ppv);
1180     IPOP3Transport_Release(pPop3Transport);
1181
1182     return hr;
1183 }
1184
1185 static HRESULT WINAPI POP3TransportCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1186 {
1187     FIXME("(%d)\n",fLock);
1188     return S_OK;
1189 }
1190
1191 static const IClassFactoryVtbl POP3TransportCFVtbl =
1192 {
1193     POP3TransportCF_QueryInterface,
1194     POP3TransportCF_AddRef,
1195     POP3TransportCF_Release,
1196     POP3TransportCF_CreateInstance,
1197     POP3TransportCF_LockServer
1198 };
1199 static const IClassFactoryVtbl *POP3TransportCF = &POP3TransportCFVtbl;
1200
1201 HRESULT POP3TransportCF_Create(REFIID riid, LPVOID *ppv)
1202 {
1203     return IClassFactory_QueryInterface((IClassFactory *)&POP3TransportCF, riid, ppv);
1204 }