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