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