]> git.ipfire.org Git - thirdparty/squid.git/blob - src/clients/FtpGateway.cc
projects / thirdparty / squid.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SourceFormat Enforcement
[thirdparty/squid.git] / src / clients / FtpGateway.cc
1 /*
2 * Copyright (C) 1996-2015 The Squid Software Foundation and contributors
3 *
4 * Squid software is distributed under GPLv2+ license and includes
5 * contributions from numerous individuals and organizations.
6 * Please see the COPYING and CONTRIBUTORS files for details.
7 */
8
9 /* DEBUG: section 09 File Transfer Protocol (FTP) */
10
11 #include "squid.h"
12 #include "acl/FilledChecklist.h"
13 #include "clients/forward.h"
14 #include "clients/FtpClient.h"
15 #include "comm.h"
16 #include "comm/ConnOpener.h"
17 #include "comm/Read.h"
18 #include "comm/TcpAcceptor.h"
19 #include "CommCalls.h"
20 #include "compat/strtoll.h"
21 #include "errorpage.h"
22 #include "fd.h"
23 #include "fde.h"
24 #include "FwdState.h"
25 #include "html_quote.h"
26 #include "HttpHdrContRange.h"
27 #include "HttpHeader.h"
28 #include "HttpHeaderRange.h"
29 #include "HttpReply.h"
30 #include "HttpRequest.h"
31 #include "ip/tools.h"
32 #include "MemBuf.h"
33 #include "mime.h"
34 #include "rfc1738.h"
35 #include "SquidConfig.h"
36 #include "SquidString.h"
37 #include "SquidTime.h"
38 #include "StatCounters.h"
39 #include "Store.h"
40 #include "tools.h"
41 #include "URL.h"
42 #include "util.h"
43 #include "wordlist.h"
44
45 #if USE_DELAY_POOLS
46 #include "DelayPools.h"
47 #include "MemObject.h"
48 #endif
49
50 #include <cerrno>
51
52 namespace Ftp
53 {
54
55 struct GatewayFlags {
56
57 /* passive mode */
58 bool pasv_supported; ///< PASV command is allowed
59 bool epsv_all_sent; ///< EPSV ALL has been used. Must abort on failures.
60 bool pasv_only;
61 bool pasv_failed; // was FwdState::flags.ftp_pasv_failed
62
63 /* authentication */
64 bool authenticated; ///< authentication success
65 bool tried_auth_anonymous; ///< auth has tried to use anonymous credentials already.
66 bool tried_auth_nopass; ///< auth tried username with no password already.
67
68 /* other */
69 bool isdir;
70 bool skip_whitespace;
71 bool rest_supported;
72 bool http_header_sent;
73 bool tried_nlst;
74 bool need_base_href;
75 bool dir_slash;
76 bool root_dir;
77 bool no_dotdot;
78 bool binary;
79 bool try_slash_hack;
80 bool put;
81 bool put_mkdir;
82 bool listformat_unknown;
83 bool listing;
84 bool completed_forwarding;
85 };
86
87 class Gateway;
88 typedef void (StateMethod)(Ftp::Gateway *);
89
90 /// FTP Gateway: An FTP client that takes an HTTP request with an ftp:// URI,
91 /// converts it into one or more FTP commands, and then
92 /// converts one or more FTP responses into the final HTTP response.
93 class Gateway : public Ftp::Client
94 {
95 CBDATA_CLASS(Gateway);
96
97 public:
98 Gateway(FwdState *);
99 virtual ~Gateway();
100 char user[MAX_URL];
101 char password[MAX_URL];
102 int password_url;
103 char *reply_hdr;
104 int reply_hdr_state;
105 String clean_url;
106 String title_url;
107 String base_href;
108 int conn_att;
109 int login_att;
110 time_t mdtm;
111 int64_t theSize;
112 wordlist *pathcomps;
113 char *filepath;
114 char *dirpath;
115 int64_t restart_offset;
116 char *proxy_host;
117 size_t list_width;
118 String cwd_message;
119 char *old_filepath;
120 char typecode;
121 MemBuf listing; ///< FTP directory listing in HTML format.
122
123 GatewayFlags flags;
124
125 public:
126 // these should all be private
127 virtual void start();
128 virtual Http::StatusCode failedHttpStatus(err_type &error);
129 int restartable();
130 void appendSuccessHeader();
131 void hackShortcut(StateMethod *nextState);
132 void unhack();
133 void readStor();
134 void parseListing();
135 MemBuf *htmlifyListEntry(const char *line);
136 void completedListing(void);
137
138 /// create a data channel acceptor and start listening.
139 void listenForDataChannel(const Comm::ConnectionPointer &conn);
140
141 int checkAuth(const HttpHeader * req_hdr);
142 void checkUrlpath();
143 void buildTitleUrl();
144 void writeReplyBody(const char *, size_t len);
145 void printfReplyBody(const char *fmt, ...);
146 virtual void completeForwarding();
147 void processHeadResponse();
148 void processReplyBody();
149 void setCurrentOffset(int64_t offset) { currentOffset = offset; }
150 int64_t getCurrentOffset() const { return currentOffset; }
151
152 virtual void dataChannelConnected(const CommConnectCbParams &io);
153 static PF ftpDataWrite;
154 virtual void timeout(const CommTimeoutCbParams &io);
155 void ftpAcceptDataConnection(const CommAcceptCbParams &io);
156
157 static HttpReply *ftpAuthRequired(HttpRequest * request, const char *realm);
158 const char *ftpRealm(void);
159 void loginFailed(void);
160
161 virtual void haveParsedReplyHeaders();
162
163 virtual bool haveControlChannel(const char *caller_name) const;
164
165 protected:
166 virtual void handleControlReply();
167 virtual void dataClosed(const CommCloseCbParams &io);
168
169 private:
170 virtual bool mayReadVirginReplyBody() const;
171 // BodyConsumer for HTTP: consume request body.
172 virtual void handleRequestBodyProducerAborted();
173
174 void loginParser(const SBuf &login, bool escaped);
175 };
176
177 } // namespace Ftp
178
179 typedef Ftp::StateMethod FTPSM; // to avoid lots of non-changes
180
181 CBDATA_NAMESPACED_CLASS_INIT(Ftp, Gateway);
182
183 typedef struct {
184 char type;
185 int64_t size;
186 char *date;
187 char *name;
188 char *showname;
189 char *link;
190 } ftpListParts;
191
192 #define CTRL_BUFLEN 1024
193 static char cbuf[CTRL_BUFLEN];
194
195 /*
196 * State machine functions
197 * send == state transition
198 * read == wait for response, and select next state transition
199 * other == Transition logic
200 */
201 static FTPSM ftpReadWelcome;
202 static FTPSM ftpSendUser;
203 static FTPSM ftpReadUser;
204 static FTPSM ftpSendPass;
205 static FTPSM ftpReadPass;
206 static FTPSM ftpSendType;
207 static FTPSM ftpReadType;
208 static FTPSM ftpSendMdtm;
209 static FTPSM ftpReadMdtm;
210 static FTPSM ftpSendSize;
211 static FTPSM ftpReadSize;
212 static FTPSM ftpSendEPRT;
213 static FTPSM ftpReadEPRT;
214 static FTPSM ftpSendPORT;
215 static FTPSM ftpReadPORT;
216 static FTPSM ftpSendPassive;
217 static FTPSM ftpReadEPSV;
218 static FTPSM ftpReadPasv;
219 static FTPSM ftpTraverseDirectory;
220 static FTPSM ftpListDir;
221 static FTPSM ftpGetFile;
222 static FTPSM ftpSendCwd;
223 static FTPSM ftpReadCwd;
224 static FTPSM ftpRestOrList;
225 static FTPSM ftpSendList;
226 static FTPSM ftpSendNlst;
227 static FTPSM ftpReadList;
228 static FTPSM ftpSendRest;
229 static FTPSM ftpReadRest;
230 static FTPSM ftpSendRetr;
231 static FTPSM ftpReadRetr;
232 static FTPSM ftpReadTransferDone;
233 static FTPSM ftpSendStor;
234 static FTPSM ftpReadStor;
235 static FTPSM ftpWriteTransferDone;
236 static FTPSM ftpSendReply;
237 static FTPSM ftpSendMkdir;
238 static FTPSM ftpReadMkdir;
239 static FTPSM ftpFail;
240 static FTPSM ftpSendQuit;
241 static FTPSM ftpReadQuit;
242
243 /************************************************
244 ** Debugs Levels used here **
245 *************************************************
246 0 CRITICAL Events
247 1 IMPORTANT Events
248 Protocol and Transmission failures.
249 2 FTP Protocol Chatter
250 3 Logic Flows
251 4 Data Parsing Flows
252 5 Data Dumps
253 7 ??
254 ************************************************/
255
256 /************************************************
257 ** State Machine Description (excluding hacks) **
258 *************************************************
259 From To
260 ---------------------------------------
261 Welcome User
262 User Pass
263 Pass Type
264 Type TraverseDirectory / GetFile
265 TraverseDirectory Cwd / GetFile / ListDir
266 Cwd TraverseDirectory / Mkdir
267 GetFile Mdtm
268 Mdtm Size
269 Size Epsv
270 ListDir Epsv
271 Epsv FileOrList
272 FileOrList Rest / Retr / Nlst / List / Mkdir (PUT /xxx;type=d)
273 Rest Retr
274 Retr / Nlst / List DataRead* (on datachannel)
275 DataRead* ReadTransferDone
276 ReadTransferDone DataTransferDone
277 Stor DataWrite* (on datachannel)
278 DataWrite* RequestPutBody** (from client)
279 RequestPutBody** DataWrite* / WriteTransferDone
280 WriteTransferDone DataTransferDone
281 DataTransferDone Quit
282 Quit -
283 ************************************************/
284
285 FTPSM *FTP_SM_FUNCS[] = {
286 ftpReadWelcome, /* BEGIN */
287 ftpReadUser, /* SENT_USER */
288 ftpReadPass, /* SENT_PASS */
289 ftpReadType, /* SENT_TYPE */
290 ftpReadMdtm, /* SENT_MDTM */
291 ftpReadSize, /* SENT_SIZE */
292 ftpReadEPRT, /* SENT_EPRT */
293 ftpReadPORT, /* SENT_PORT */
294 ftpReadEPSV, /* SENT_EPSV_ALL */
295 ftpReadEPSV, /* SENT_EPSV_1 */
296 ftpReadEPSV, /* SENT_EPSV_2 */
297 ftpReadPasv, /* SENT_PASV */
298 ftpReadCwd, /* SENT_CWD */
299 ftpReadList, /* SENT_LIST */
300 ftpReadList, /* SENT_NLST */
301 ftpReadRest, /* SENT_REST */
302 ftpReadRetr, /* SENT_RETR */
303 ftpReadStor, /* SENT_STOR */
304 ftpReadQuit, /* SENT_QUIT */
305 ftpReadTransferDone, /* READING_DATA (RETR,LIST,NLST) */
306 ftpWriteTransferDone, /* WRITING_DATA (STOR) */
307 ftpReadMkdir, /* SENT_MKDIR */
308 NULL, /* SENT_FEAT */
309 NULL, /* SENT_PWD */
310 NULL, /* SENT_CDUP*/
311 NULL, /* SENT_DATA_REQUEST */
312 NULL /* SENT_COMMAND */
313 };
314
315 /// handler called by Comm when FTP data channel is closed unexpectedly
316 void
317 Ftp::Gateway::dataClosed(const CommCloseCbParams &io)
318 {
319 Ftp::Client::dataClosed(io);
320 failed(ERR_FTP_FAILURE, 0);
321 /* failed closes ctrl.conn and frees ftpState */
322
323 /* NP: failure recovery may be possible when its only a data.conn failure.
324 * if the ctrl.conn is still fine, we can send ABOR down it and retry.
325 * Just need to watch out for wider Squid states like shutting down or reconfigure.
326 */
327 }
328
329 Ftp::Gateway::Gateway(FwdState *fwdState):
330 AsyncJob("FtpStateData"),
331 Ftp::Client(fwdState),
332 password_url(0),
333 reply_hdr(NULL),
334 reply_hdr_state(0),
335 conn_att(0),
336 login_att(0),
337 mdtm(-1),
338 theSize(-1),
339 pathcomps(NULL),
340 filepath(NULL),
341 dirpath(NULL),
342 restart_offset(0),
343 proxy_host(NULL),
344 list_width(0),
345 old_filepath(NULL),
346 typecode('\0')
347 {
348 debugs(9, 3, entry->url());
349
350 *user = 0;
351 *password = 0;
352 memset(&flags, 0, sizeof(flags));
353
354 if (Config.Ftp.passive && !flags.pasv_failed)
355 flags.pasv_supported = 1;
356
357 flags.rest_supported = 1;
358
359 if (request->method == Http::METHOD_PUT)
360 flags.put = 1;
361
362 initReadBuf();
363 }
364
365 Ftp::Gateway::~Gateway()
366 {
367 debugs(9, 3, entry->url());
368
369 if (Comm::IsConnOpen(ctrl.conn)) {
370 debugs(9, DBG_IMPORTANT, "Internal bug: FTP Gateway left open " <<
371 "control channel " << ctrl.conn);
372 }
373
374 if (reply_hdr) {
375 memFree(reply_hdr, MEM_8K_BUF);
376 reply_hdr = NULL;
377 }
378
379 if (pathcomps)
380 wordlistDestroy(&pathcomps);
381
382 cwd_message.clean();
383 xfree(old_filepath);
384 title_url.clean();
385 base_href.clean();
386 xfree(filepath);
387 xfree(dirpath);
388 }
389
390 /**
391 * Parse a possible login username:password pair.
392 * Produces filled member variables user, password, password_url if anything found.
393 *
394 * \param login a decoded Basic authentication credential token or URI user-info token
395 * \param escaped whether to URL-decode the token after extracting user and password
396 */
397 void
398 Ftp::Gateway::loginParser(const SBuf &login, bool escaped)
399 {
400 debugs(9, 4, "login=" << login << ", escaped=" << escaped);
401 debugs(9, 9, "IN : login=" << login << ", escaped=" << escaped << ", user=" << user << ", password=" << password);
402
403 if (login.isEmpty())
404 return;
405
406 const SBuf::size_type colonPos = login.find(':');
407
408 /* If there was a username part with at least one character use it.
409 * Ignore 0-length username portion, retain what we have already.
410 */
411 if (colonPos == SBuf::npos || colonPos > 0) {
412 const SBuf userName = login.substr(0, colonPos);
413 SBuf::size_type upto = userName.copy(user, sizeof(user)-1);
414 user[upto]='\0';
415 debugs(9, 9, "found user=" << userName << ' ' <<
416 (upto != userName.length() ? ", truncated-to=" : ", length=") << upto <<
417 ", escaped=" << escaped);
418 if (escaped)
419 rfc1738_unescape(user);
420 debugs(9, 9, "found user=" << user << " (" << strlen(user) << ") unescaped.");
421 }
422
423 /* If there was a password part.
424 * For 0-length password clobber what we have already, this means explicitly none
425 */
426 if (colonPos != SBuf::npos) {
427 const SBuf pass = login.substr(colonPos+1, SBuf::npos);
428 SBuf::size_type upto = pass.copy(password, sizeof(password)-1);
429 password[upto]='\0';
430 debugs(9, 9, "found password=" << pass << " " <<
431 (upto != pass.length() ? ", truncated-to=" : ", length=") << upto <<
432 ", escaped=" << escaped);
433 if (escaped) {
434 rfc1738_unescape(password);
435 password_url = 1;
436 }
437 debugs(9, 9, "found password=" << password << " (" << strlen(password) << ") unescaped.");
438 }
439
440 debugs(9, 9, "OUT: login=" << login << ", escaped=" << escaped << ", user=" << user << ", password=" << password);
441 }
442
443 void
444 Ftp::Gateway::listenForDataChannel(const Comm::ConnectionPointer &conn)
445 {
446 assert(!Comm::IsConnOpen(data.conn));
447
448 typedef CommCbMemFunT<Gateway, CommAcceptCbParams> AcceptDialer;
449 typedef AsyncCallT<AcceptDialer> AcceptCall;
450 RefCount<AcceptCall> call = static_cast<AcceptCall*>(JobCallback(11, 5, AcceptDialer, this, Ftp::Gateway::ftpAcceptDataConnection));
451 Subscription::Pointer sub = new CallSubscription<AcceptCall>(call);
452 const char *note = entry->url();
453
454 /* open the conn if its not already open */
455 if (!Comm::IsConnOpen(conn)) {
456 conn->fd = comm_open_listener(SOCK_STREAM, IPPROTO_TCP, conn->local, conn->flags, note);
457 if (!Comm::IsConnOpen(conn)) {
458 debugs(5, DBG_CRITICAL, HERE << "comm_open_listener failed:" << conn->local << " error: " << errno);
459 return;
460 }
461 debugs(9, 3, HERE << "Unconnected data socket created on " << conn);
462 }
463
464 conn->tos = ctrl.conn->tos;
465 conn->nfmark = ctrl.conn->nfmark;
466
467 assert(Comm::IsConnOpen(conn));
468 AsyncJob::Start(new Comm::TcpAcceptor(conn, note, sub));
469
470 // Ensure we have a copy of the FD opened for listening and a close handler on it.
471 data.opened(conn, dataCloser());
472 switchTimeoutToDataChannel();
473 }
474
475 void
476 Ftp::Gateway::timeout(const CommTimeoutCbParams &io)
477 {
478 if (SENT_PASV == state) {
479 /* stupid ftp.netscape.com, of FTP server behind stupid firewall rules */
480 flags.pasv_supported = false;
481 debugs(9, DBG_IMPORTANT, "FTP Gateway timeout in SENT_PASV state");
482
483 // cancel the data connection setup.
484 if (data.opener != NULL) {
485 data.opener->cancel("timeout");
486 data.opener = NULL;
487 }
488 data.close();
489 }
490
491 Ftp::Client::timeout(io);
492 }
493
494 static const char *Month[] = {
495 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
496 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
497 };
498
499 static int
500 is_month(const char *buf)
501 {
502 int i;
503
504 for (i = 0; i < 12; ++i)
505 if (!strcasecmp(buf, Month[i]))
506 return 1;
507
508 return 0;
509 }
510
511 static void
512 ftpListPartsFree(ftpListParts ** parts)
513 {
514 safe_free((*parts)->date);
515 safe_free((*parts)->name);
516 safe_free((*parts)->showname);
517 safe_free((*parts)->link);
518 safe_free(*parts);
519 }
520
521 #define MAX_TOKENS 64
522
523 static ftpListParts *
524 ftpListParseParts(const char *buf, struct Ftp::GatewayFlags flags)
525 {
526 ftpListParts *p = NULL;
527 char *t = NULL;
528 const char *ct = NULL;
529 char *tokens[MAX_TOKENS];
530 int i;
531 int n_tokens;
532 static char tbuf[128];
533 char *xbuf = NULL;
534 static int scan_ftp_initialized = 0;
535 static regex_t scan_ftp_integer;
536 static regex_t scan_ftp_time;
537 static regex_t scan_ftp_dostime;
538 static regex_t scan_ftp_dosdate;
539
540 if (!scan_ftp_initialized) {
541 scan_ftp_initialized = 1;
542 regcomp(&scan_ftp_integer, "^[0123456789]+$", REG_EXTENDED | REG_NOSUB);
543 regcomp(&scan_ftp_time, "^[0123456789:]+$", REG_EXTENDED | REG_NOSUB);
544 regcomp(&scan_ftp_dosdate, "^[0123456789]+-[0123456789]+-[0123456789]+$", REG_EXTENDED | REG_NOSUB);
545 regcomp(&scan_ftp_dostime, "^[0123456789]+:[0123456789]+[AP]M$", REG_EXTENDED | REG_NOSUB | REG_ICASE);
546 }
547
548 if (buf == NULL)
549 return NULL;
550
551 if (*buf == '\0')
552 return NULL;
553
554 p = (ftpListParts *)xcalloc(1, sizeof(ftpListParts));
555
556 n_tokens = 0;
557
558 memset(tokens, 0, sizeof(tokens));
559
560 xbuf = xstrdup(buf);
561
562 if (flags.tried_nlst) {
563 /* Machine readable format, one name per line */
564 p->name = xbuf;
565 p->type = '\0';
566 return p;
567 }
568
569 for (t = strtok(xbuf, w_space); t && n_tokens < MAX_TOKENS; t = strtok(NULL, w_space)) {
570 tokens[n_tokens] = xstrdup(t);
571 ++n_tokens;
572 }
573
574 xfree(xbuf);
575
576 /* locate the Month field */
577 for (i = 3; i < n_tokens - 2; ++i) {
578 char *size = tokens[i - 1];
579 char *month = tokens[i];
580 char *day = tokens[i + 1];
581 char *year = tokens[i + 2];
582
583 if (!is_month(month))
584 continue;
585
586 if (regexec(&scan_ftp_integer, size, 0, NULL, 0) != 0)
587 continue;
588
589 if (regexec(&scan_ftp_integer, day, 0, NULL, 0) != 0)
590 continue;
591
592 if (regexec(&scan_ftp_time, year, 0, NULL, 0) != 0) /* Yr | hh:mm */
593 continue;
594
595 snprintf(tbuf, 128, "%s %2s %5s",
596 month, day, year);
597
598 if (!strstr(buf, tbuf))
599 snprintf(tbuf, 128, "%s %2s %-5s",
600 month, day, year);
601
602 char const *copyFrom = NULL;
603
604 if ((copyFrom = strstr(buf, tbuf))) {
605 p->type = *tokens[0];
606 p->size = strtoll(size, NULL, 10);
607 p->date = xstrdup(tbuf);
608
609 if (flags.skip_whitespace) {
610 copyFrom += strlen(tbuf);
611
612 while (strchr(w_space, *copyFrom))
613 ++copyFrom;
614 } else {
615 /* XXX assumes a single space between date and filename
616 * suggested by: Nathan.Bailey@cc.monash.edu.au and
617 * Mike Battersby <mike@starbug.bofh.asn.au> */
618 copyFrom += strlen(tbuf) + 1;
619 }
620
621 p->name = xstrdup(copyFrom);
622
623 if (p->type == 'l' && (t = strstr(p->name, " -> "))) {
624 *t = '\0';
625 p->link = xstrdup(t + 4);
626 }
627
628 goto found;
629 }
630
631 break;
632 }
633
634 /* try it as a DOS listing, 04-05-70 09:33PM ... */
635 if (n_tokens > 3 &&
636 regexec(&scan_ftp_dosdate, tokens[0], 0, NULL, 0) == 0 &&
637 regexec(&scan_ftp_dostime, tokens[1], 0, NULL, 0) == 0) {
638 if (!strcasecmp(tokens[2], "<dir>")) {
639 p->type = 'd';
640 } else {
641 p->type = '-';
642 p->size = strtoll(tokens[2], NULL, 10);
643 }
644
645 snprintf(tbuf, 128, "%s %s", tokens[0], tokens[1]);
646 p->date = xstrdup(tbuf);
647
648 if (p->type == 'd') {
649 /* Directory.. name begins with first printable after <dir> */
650 ct = strstr(buf, tokens[2]);
651 ct += strlen(tokens[2]);
652
653 while (xisspace(*ct))
654 ++ct;
655
656 if (!*ct)
657 ct = NULL;
658 } else {
659 /* A file. Name begins after size, with a space in between */
660 snprintf(tbuf, 128, " %s %s", tokens[2], tokens[3]);
661 ct = strstr(buf, tbuf);
662
663 if (ct) {
664 ct += strlen(tokens[2]) + 2;
665 }
666 }
667
668 p->name = xstrdup(ct ? ct : tokens[3]);
669 goto found;
670 }
671
672 /* Try EPLF format; carson@lehman.com */
673 if (buf[0] == '+') {
674 ct = buf + 1;
675 p->type = 0;
676
677 while (ct && *ct) {
678 time_t tm;
679 int l = strcspn(ct, ",");
680 char *tmp;
681
682 if (l < 1)
683 goto blank;
684
685 switch (*ct) {
686
687 case '\t':
688 p->name = xstrndup(ct + 1, l + 1);
689 break;
690
691 case 's':
692 p->size = atoi(ct + 1);
693 break;
694
695 case 'm':
696 tm = (time_t) strtol(ct + 1, &tmp, 0);
697
698 if (tmp != ct + 1)
699 break; /* not a valid integer */
700
701 p->date = xstrdup(ctime(&tm));
702
703 *(strstr(p->date, "\n")) = '\0';
704
705 break;
706
707 case '/':
708 p->type = 'd';
709
710 break;
711
712 case 'r':
713 p->type = '-';
714
715 break;
716
717 case 'i':
718 break;
719
720 default:
721 break;
722 }
723
724 blank:
725 ct = strstr(ct, ",");
726
727 if (ct) {
728 ++ct;
729 }
730 }
731
732 if (p->type == 0) {
733 p->type = '-';
734 }
735
736 if (p->name)
737 goto found;
738 else
739 safe_free(p->date);
740 }
741
742 found:
743
744 for (i = 0; i < n_tokens; ++i)
745 xfree(tokens[i]);
746
747 if (!p->name)
748 ftpListPartsFree(&p); /* cleanup */
749
750 return p;
751 }
752
753 MemBuf *
754 Ftp::Gateway::htmlifyListEntry(const char *line)
755 {
756 char icon[2048];
757 char href[2048 + 40];
758 char text[ 2048];
759 char size[ 2048];
760 char chdir[ 2048 + 40];
761 char view[ 2048 + 40];
762 char download[ 2048 + 40];
763 char link[ 2048 + 40];
764 MemBuf *html;
765 char prefix[2048];
766 ftpListParts *parts;
767 *icon = *href = *text = *size = *chdir = *view = *download = *link = '\0';
768
769 debugs(9, 7, HERE << " line ={" << line << "}");
770
771 if (strlen(line) > 1024) {
772 html = new MemBuf();
773 html->init();
774 html->Printf("<tr><td colspan=\"5\">%s</td></tr>\n", line);
775 return html;
776 }
777
778 if (flags.dir_slash && dirpath && typecode != 'D')
779 snprintf(prefix, 2048, "%s/", rfc1738_escape_part(dirpath));
780 else
781 prefix[0] = '\0';
782
783 if ((parts = ftpListParseParts(line, flags)) == NULL) {
784 const char *p;
785
786 html = new MemBuf();
787 html->init();
788 html->Printf("<tr class=\"entry\"><td colspan=\"5\">%s</td></tr>\n", line);
789
790 for (p = line; *p && xisspace(*p); ++p);
791 if (*p && !xisspace(*p))
792 flags.listformat_unknown = 1;
793
794 return html;
795 }
796
797 if (!strcmp(parts->name, ".") || !strcmp(parts->name, "..")) {
798 ftpListPartsFree(&parts);
799 return NULL;
800 }
801
802 parts->size += 1023;
803 parts->size >>= 10;
804 parts->showname = xstrdup(parts->name);
805
806 /* {icon} {text} . . . {date}{size}{chdir}{view}{download}{link}\n */
807 xstrncpy(href, rfc1738_escape_part(parts->name), 2048);
808
809 xstrncpy(text, parts->showname, 2048);
810
811 switch (parts->type) {
812
813 case 'd':
814 snprintf(icon, 2048, "<img border=\"0\" src=\"%s\" alt=\"%-6s\">",
815 mimeGetIconURL("internal-dir"),
816 "[DIR]");
817 strcat(href, "/"); /* margin is allocated above */
818 break;
819
820 case 'l':
821 snprintf(icon, 2048, "<img border=\"0\" src=\"%s\" alt=\"%-6s\">",
822 mimeGetIconURL("internal-link"),
823 "[LINK]");
824 /* sometimes there is an 'l' flag, but no "->" link */
825
826 if (parts->link) {
827 char *link2 = xstrdup(html_quote(rfc1738_escape(parts->link)));
828 snprintf(link, 2048, " -&gt; <a href=\"%s%s\">%s</a>",
829 *link2 != '/' ? prefix : "", link2,
830 html_quote(parts->link));
831 safe_free(link2);
832 }
833
834 break;
835
836 case '\0':
837 snprintf(icon, 2048, "<img border=\"0\" src=\"%s\" alt=\"%-6s\">",
838 mimeGetIconURL(parts->name),
839 "[UNKNOWN]");
840 snprintf(chdir, 2048, "<a href=\"%s/;type=d\"><img border=\"0\" src=\"%s\" "
841 "alt=\"[DIR]\"></a>",
842 rfc1738_escape_part(parts->name),
843 mimeGetIconURL("internal-dir"));
844 break;
845
846 case '-':
847
848 default:
849 snprintf(icon, 2048, "<img border=\"0\" src=\"%s\" alt=\"%-6s\">",
850 mimeGetIconURL(parts->name),
851 "[FILE]");
852 snprintf(size, 2048, " %6" PRId64 "k", parts->size);
853 break;
854 }
855
856 if (parts->type != 'd') {
857 if (mimeGetViewOption(parts->name)) {
858 snprintf(view, 2048, "<a href=\"%s%s;type=a\"><img border=\"0\" src=\"%s\" "
859 "alt=\"[VIEW]\"></a>",
860 prefix, href, mimeGetIconURL("internal-view"));
861 }
862
863 if (mimeGetDownloadOption(parts->name)) {
864 snprintf(download, 2048, "<a href=\"%s%s;type=i\"><img border=\"0\" src=\"%s\" "
865 "alt=\"[DOWNLOAD]\"></a>",
866 prefix, href, mimeGetIconURL("internal-download"));
867 }
868 }
869
870 /* construct the table row from parts. */
871 html = new MemBuf();
872 html->init();
873 html->Printf("<tr class=\"entry\">"
874 "<td class=\"icon\"><a href=\"%s%s\">%s</a></td>"
875 "<td class=\"filename\"><a href=\"%s%s\">%s</a></td>"
876 "<td class=\"date\">%s</td>"
877 "<td class=\"size\">%s</td>"
878 "<td class=\"actions\">%s%s%s%s</td>"
879 "</tr>\n",
880 prefix, href, icon,
881 prefix, href, html_quote(text),
882 parts->date,
883 size,
884 chdir, view, download, link);
885
886 ftpListPartsFree(&parts);
887 return html;
888 }
889
890 void
891 Ftp::Gateway::parseListing()
892 {
893 char *buf = data.readBuf->content();
894 char *sbuf; /* NULL-terminated copy of termedBuf */
895 char *end;
896 char *line;
897 char *s;
898 MemBuf *t;
899 size_t linelen;
900 size_t usable;
901 size_t len = data.readBuf->contentSize();
902
903 if (!len) {
904 debugs(9, 3, HERE << "no content to parse for " << entry->url() );
905 return;
906 }
907
908 /*
909 * We need a NULL-terminated buffer for scanning, ick
910 */
911 sbuf = (char *)xmalloc(len + 1);
912 xstrncpy(sbuf, buf, len + 1);
913 end = sbuf + len - 1;
914
915 while (*end != '\r' && *end != '\n' && end > sbuf)
916 --end;
917
918 usable = end - sbuf;
919
920 debugs(9, 3, HERE << "usable = " << usable << " of " << len << " bytes.");
921
922 if (usable == 0) {
923 if (buf[0] == '\0' && len == 1) {
924 debugs(9, 3, HERE << "NIL ends data from " << entry->url() << " transfer problem?");
925 data.readBuf->consume(len);
926 } else {
927 debugs(9, 3, HERE << "didn't find end for " << entry->url());
928 debugs(9, 3, HERE << "buffer remains (" << len << " bytes) '" << rfc1738_do_escape(buf,0) << "'");
929 }
930 xfree(sbuf);
931 return;
932 }
933
934 debugs(9, 3, HERE << (unsigned long int)len << " bytes to play with");
935
936 line = (char *)memAllocate(MEM_4K_BUF);
937 ++end;
938 s = sbuf;
939 s += strspn(s, crlf);
940
941 for (; s < end; s += strcspn(s, crlf), s += strspn(s, crlf)) {
942 debugs(9, 7, HERE << "s = {" << s << "}");
943 linelen = strcspn(s, crlf) + 1;
944
945 if (linelen < 2)
946 break;
947
948 if (linelen > 4096)
949 linelen = 4096;
950
951 xstrncpy(line, s, linelen);
952
953 debugs(9, 7, HERE << "{" << line << "}");
954
955 if (!strncmp(line, "total", 5))
956 continue;
957
958 t = htmlifyListEntry(line);
959
960 if ( t != NULL) {
961 debugs(9, 7, HERE << "listing append: t = {" << t->contentSize() << ", '" << t->content() << "'}");
962 listing.append(t->content(), t->contentSize());
963 //leak? delete t;
964 }
965 }
966
967 debugs(9, 7, HERE << "Done.");
968 data.readBuf->consume(usable);
969 memFree(line, MEM_4K_BUF);
970 xfree(sbuf);
971 }
972
973 void
974 Ftp::Gateway::processReplyBody()
975 {
976 debugs(9, 3, status());
977
978 if (request->method == Http::METHOD_HEAD && (flags.isdir || theSize != -1)) {
979 serverComplete();
980 return;
981 }
982
983 /* Directory listings are special. They write ther own headers via the error objects */
984 if (!flags.http_header_sent && data.readBuf->contentSize() >= 0 && !flags.isdir)
985 appendSuccessHeader();
986
987 if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
988 /*
989 * probably was aborted because content length exceeds one
990 * of the maximum size limits.
991 */
992 abortTransaction("entry aborted after calling appendSuccessHeader()");
993 return;
994 }
995
996 #if USE_ADAPTATION
997
998 if (adaptationAccessCheckPending) {
999 debugs(9, 3, "returning from Ftp::Gateway::processReplyBody due to adaptationAccessCheckPending");
1000 return;
1001 }
1002
1003 #endif
1004
1005 if (flags.isdir) {
1006 if (!flags.listing) {
1007 flags.listing = 1;
1008 listing.reset();
1009 }
1010 parseListing();
1011 maybeReadVirginBody();
1012 return;
1013 } else if (const int csize = data.readBuf->contentSize()) {
1014 writeReplyBody(data.readBuf->content(), csize);
1015 debugs(9, 5, HERE << "consuming " << csize << " bytes of readBuf");
1016 data.readBuf->consume(csize);
1017 }
1018
1019 entry->flush();
1020
1021 maybeReadVirginBody();
1022 }
1023
1024 /**
1025 * Locates the FTP user:password login.
1026 *
1027 * Highest to lowest priority:
1028 * - Checks URL (ftp://user:pass@domain)
1029 * - Authorization: Basic header
1030 * - squid.conf anonymous-FTP settings (default: anonymous:Squid@).
1031 *
1032 * Special Case: A username-only may be provided in the URL and password in the HTTP headers.
1033 *
1034 * TODO: we might be able to do something about locating username from other sources:
1035 * ie, external ACL user=* tag or ident lookup
1036 *
1037 \retval 1 if we have everything needed to complete this request.
1038 \retval 0 if something is missing.
1039 */
1040 int
1041 Ftp::Gateway::checkAuth(const HttpHeader * req_hdr)
1042 {
1043 /* default username */
1044 xstrncpy(user, "anonymous", MAX_URL);
1045
1046 #if HAVE_AUTH_MODULE_BASIC
1047 /* Check HTTP Authorization: headers (better than defaults, but less than URL) */
1048 const SBuf auth(req_hdr->getAuth(HDR_AUTHORIZATION, "Basic"));
1049 if (!auth.isEmpty()) {
1050 flags.authenticated = 1;
1051 loginParser(auth, false);
1052 }
1053 /* we fail with authorization-required error later IFF the FTP server requests it */
1054 #endif
1055
1056 /* Test URL login syntax. Overrides any headers received. */
1057 loginParser(request->url.userInfo(), true);
1058
1059 /* name is missing. thats fatal. */
1060 if (!user[0])
1061 fatal("FTP login parsing destroyed username info");
1062
1063 /* name + password == success */
1064 if (password[0])
1065 return 1;
1066
1067 /* Setup default FTP password settings */
1068 /* this has to be done last so that we can have a no-password case above. */
1069 if (!password[0]) {
1070 if (strcmp(user, "anonymous") == 0 && !flags.tried_auth_anonymous) {
1071 xstrncpy(password, Config.Ftp.anon_user, MAX_URL);
1072 flags.tried_auth_anonymous=1;
1073 return 1;
1074 } else if (!flags.tried_auth_nopass) {
1075 xstrncpy(password, null_string, MAX_URL);
1076 flags.tried_auth_nopass=1;
1077 return 1;
1078 }
1079 }
1080
1081 return 0; /* different username */
1082 }
1083
1084 static String str_type_eq;
1085 void
1086 Ftp::Gateway::checkUrlpath()
1087 {
1088 int l;
1089 size_t t;
1090
1091 if (str_type_eq.size()==0) //hack. String doesn't support global-static
1092 str_type_eq="type=";
1093
1094 if ((t = request->urlpath.rfind(';')) != String::npos) {
1095 if (request->urlpath.substr(t+1,t+1+str_type_eq.size())==str_type_eq) {
1096 typecode = (char)xtoupper(request->urlpath[t+str_type_eq.size()+1]);
1097 request->urlpath.cut(t);
1098 }
1099 }
1100
1101 l = request->urlpath.size();
1102 /* check for null path */
1103
1104 if (!l) {
1105 flags.isdir = 1;
1106 flags.root_dir = 1;
1107 flags.need_base_href = 1; /* Work around broken browsers */
1108 } else if (!request->urlpath.cmp("/%2f/")) {
1109 /* UNIX root directory */
1110 flags.isdir = 1;
1111 flags.root_dir = 1;
1112 } else if ((l >= 1) && (request->urlpath[l - 1] == '/')) {
1113 /* Directory URL, ending in / */
1114 flags.isdir = 1;
1115
1116 if (l == 1)
1117 flags.root_dir = 1;
1118 } else {
1119 flags.dir_slash = 1;
1120 }
1121 }
1122
1123 void
1124 Ftp::Gateway::buildTitleUrl()
1125 {
1126 title_url = "ftp://";
1127
1128 if (strcmp(user, "anonymous")) {
1129 title_url.append(user);
1130 title_url.append("@");
1131 }
1132
1133 title_url.append(request->GetHost());
1134
1135 if (request->port != urlDefaultPort(AnyP::PROTO_FTP)) {
1136 title_url.append(":");
1137 title_url.append(xitoa(request->port));
1138 }
1139
1140 title_url.append (request->urlpath);
1141
1142 base_href = "ftp://";
1143
1144 if (strcmp(user, "anonymous") != 0) {
1145 base_href.append(rfc1738_escape_part(user));
1146
1147 if (password_url) {
1148 base_href.append (":");
1149 base_href.append(rfc1738_escape_part(password));
1150 }
1151
1152 base_href.append("@");
1153 }
1154
1155 base_href.append(request->GetHost());
1156
1157 if (request->port != urlDefaultPort(AnyP::PROTO_FTP)) {
1158 base_href.append(":");
1159 base_href.append(xitoa(request->port));
1160 }
1161
1162 base_href.append(request->urlpath);
1163 base_href.append("/");
1164 }
1165
1166 void
1167 Ftp::Gateway::start()
1168 {
1169 if (!checkAuth(&request->header)) {
1170 /* create appropriate reply */
1171 HttpReply *reply = ftpAuthRequired(request, ftpRealm());
1172 entry->replaceHttpReply(reply);
1173 serverComplete();
1174 return;
1175 }
1176
1177 checkUrlpath();
1178 buildTitleUrl();
1179 debugs(9, 5, HERE << "FD " << ctrl.conn->fd << " : host=" << request->GetHost() <<
1180 ", path=" << request->urlpath << ", user=" << user << ", passwd=" << password);
1181 state = BEGIN;
1182 Ftp::Client::start();
1183 }
1184
1185 /* ====================================================================== */
1186
1187 void
1188 Ftp::Gateway::handleControlReply()
1189 {
1190 Ftp::Client::handleControlReply();
1191 if (ctrl.message == NULL)
1192 return; // didn't get complete reply yet
1193
1194 /* Copy the message except for the last line to cwd_message to be
1195 * printed in error messages.
1196 */
1197 for (wordlist *w = ctrl.message; w && w->next; w = w->next) {
1198 cwd_message.append('\n');
1199 cwd_message.append(w->key);
1200 }
1201
1202 FTP_SM_FUNCS[state] (this);
1203 }
1204
1205 /* ====================================================================== */
1206
1207 static void
1208 ftpReadWelcome(Ftp::Gateway * ftpState)
1209 {
1210 int code = ftpState->ctrl.replycode;
1211 debugs(9, 3, HERE);
1212
1213 if (ftpState->flags.pasv_only)
1214 ++ ftpState->login_att;
1215
1216 if (code == 220) {
1217 if (ftpState->ctrl.message) {
1218 if (strstr(ftpState->ctrl.message->key, "NetWare"))
1219 ftpState->flags.skip_whitespace = 1;
1220 }
1221
1222 ftpSendUser(ftpState);
1223 } else if (code == 120) {
1224 if (NULL != ftpState->ctrl.message)
1225 debugs(9, DBG_IMPORTANT, "FTP server is busy: " << ftpState->ctrl.message->key);
1226
1227 return;
1228 } else {
1229 ftpFail(ftpState);
1230 }
1231 }
1232
1233 /**
1234 * Translate FTP login failure into HTTP error
1235 * this is an attmpt to get the 407 message to show up outside Squid.
1236 * its NOT a general failure. But a correct FTP response type.
1237 */
1238 void
1239 Ftp::Gateway::loginFailed()
1240 {
1241 ErrorState *err = NULL;
1242 const char *command, *reply;
1243
1244 if ((state == SENT_USER || state == SENT_PASS) && ctrl.replycode >= 400) {
1245 if (ctrl.replycode == 421 || ctrl.replycode == 426) {
1246 // 421/426 - Service Overload - retry permitted.
1247 err = new ErrorState(ERR_FTP_UNAVAILABLE, Http::scServiceUnavailable, fwd->request);
1248 } else if (ctrl.replycode >= 430 && ctrl.replycode <= 439) {
1249 // 43x - Invalid or Credential Error - retry challenge required.
1250 err = new ErrorState(ERR_FTP_FORBIDDEN, Http::scUnauthorized, fwd->request);
1251 } else if (ctrl.replycode >= 530 && ctrl.replycode <= 539) {
1252 // 53x - Credentials Missing - retry challenge required
1253 if (password_url) // but they were in the URI! major fail.
1254 err = new ErrorState(ERR_FTP_FORBIDDEN, Http::scForbidden, fwd->request);
1255 else
1256 err = new ErrorState(ERR_FTP_FORBIDDEN, Http::scUnauthorized, fwd->request);
1257 }
1258 }
1259
1260 // any other problems are general falures.
1261 if (!err) {
1262 ftpFail(this);
1263 return;
1264 }
1265
1266 err->ftp.server_msg = ctrl.message;
1267
1268 ctrl.message = NULL;
1269
1270 if (old_request)
1271 command = old_request;
1272 else
1273 command = ctrl.last_command;
1274
1275 if (command && strncmp(command, "PASS", 4) == 0)
1276 command = "PASS <yourpassword>";
1277
1278 if (old_reply)
1279 reply = old_reply;
1280 else
1281 reply = ctrl.last_reply;
1282
1283 if (command)
1284 err->ftp.request = xstrdup(command);
1285
1286 if (reply)
1287 err->ftp.reply = xstrdup(reply);
1288
1289 HttpReply *newrep = err->BuildHttpReply();
1290 delete err;
1291
1292 #if HAVE_AUTH_MODULE_BASIC
1293 /* add Authenticate header */
1294 newrep->header.putAuth("Basic", ftpRealm());
1295 #endif
1296
1297 // add it to the store entry for response....
1298 entry->replaceHttpReply(newrep);
1299 serverComplete();
1300 }
1301
1302 const char *
1303 Ftp::Gateway::ftpRealm()
1304 {
1305 static char realm[8192];
1306
1307 /* This request is not fully authenticated */
1308 if (!request) {
1309 snprintf(realm, 8192, "FTP %s unknown", user);
1310 } else if (request->port == 21) {
1311 snprintf(realm, 8192, "FTP %s %s", user, request->GetHost());
1312 } else {
1313 snprintf(realm, 8192, "FTP %s %s port %d", user, request->GetHost(), request->port);
1314 }
1315 return realm;
1316 }
1317
1318 static void
1319 ftpSendUser(Ftp::Gateway * ftpState)
1320 {
1321 /* check the server control channel is still available */
1322 if (!ftpState || !ftpState->haveControlChannel("ftpSendUser"))
1323 return;
1324
1325 if (ftpState->proxy_host != NULL)
1326 snprintf(cbuf, CTRL_BUFLEN, "USER %s@%s\r\n",
1327 ftpState->user,
1328 ftpState->request->GetHost());
1329 else
1330 snprintf(cbuf, CTRL_BUFLEN, "USER %s\r\n", ftpState->user);
1331
1332 ftpState->writeCommand(cbuf);
1333
1334 ftpState->state = Ftp::Client::SENT_USER;
1335 }
1336
1337 static void
1338 ftpReadUser(Ftp::Gateway * ftpState)
1339 {
1340 int code = ftpState->ctrl.replycode;
1341 debugs(9, 3, HERE);
1342
1343 if (code == 230) {
1344 ftpReadPass(ftpState);
1345 } else if (code == 331) {
1346 ftpSendPass(ftpState);
1347 } else {
1348 ftpState->loginFailed();
1349 }
1350 }
1351
1352 static void
1353 ftpSendPass(Ftp::Gateway * ftpState)
1354 {
1355 /* check the server control channel is still available */
1356 if (!ftpState || !ftpState->haveControlChannel("ftpSendPass"))
1357 return;
1358
1359 snprintf(cbuf, CTRL_BUFLEN, "PASS %s\r\n", ftpState->password);
1360 ftpState->writeCommand(cbuf);
1361 ftpState->state = Ftp::Client::SENT_PASS;
1362 }
1363
1364 static void
1365 ftpReadPass(Ftp::Gateway * ftpState)
1366 {
1367 int code = ftpState->ctrl.replycode;
1368 debugs(9, 3, HERE << "code=" << code);
1369
1370 if (code == 230) {
1371 ftpSendType(ftpState);
1372 } else {
1373 ftpState->loginFailed();
1374 }
1375 }
1376
1377 static void
1378 ftpSendType(Ftp::Gateway * ftpState)
1379 {
1380 const char *t;
1381 const char *filename;
1382 char mode;
1383
1384 /* check the server control channel is still available */
1385 if (!ftpState || !ftpState->haveControlChannel("ftpSendType"))
1386 return;
1387
1388 /*
1389 * Ref section 3.2.2 of RFC 1738
1390 */
1391 mode = ftpState->typecode;
1392
1393 switch (mode) {
1394
1395 case 'D':
1396 mode = 'A';
1397 break;
1398
1399 case 'A':
1400
1401 case 'I':
1402 break;
1403
1404 default:
1405
1406 if (ftpState->flags.isdir) {
1407 mode = 'A';
1408 } else {
1409 t = ftpState->request->urlpath.rpos('/');
1410 filename = t ? t + 1 : ftpState->request->urlpath.termedBuf();
1411 mode = mimeGetTransferMode(filename);
1412 }
1413
1414 break;
1415 }
1416
1417 if (mode == 'I')
1418 ftpState->flags.binary = 1;
1419 else
1420 ftpState->flags.binary = 0;
1421
1422 snprintf(cbuf, CTRL_BUFLEN, "TYPE %c\r\n", mode);
1423
1424 ftpState->writeCommand(cbuf);
1425
1426 ftpState->state = Ftp::Client::SENT_TYPE;
1427 }
1428
1429 static void
1430 ftpReadType(Ftp::Gateway * ftpState)
1431 {
1432 int code = ftpState->ctrl.replycode;
1433 char *path;
1434 char *d, *p;
1435 debugs(9, 3, HERE << "code=" << code);
1436
1437 if (code == 200) {
1438 p = path = xstrdup(ftpState->request->urlpath.termedBuf());
1439
1440 if (*p == '/')
1441 ++p;
1442
1443 while (*p) {
1444 d = p;
1445 p += strcspn(p, "/");
1446
1447 if (*p) {
1448 *p = '\0';
1449 ++p;
1450 }
1451
1452 rfc1738_unescape(d);
1453
1454 if (*d)
1455 wordlistAdd(&ftpState->pathcomps, d);
1456 }
1457
1458 xfree(path);
1459
1460 if (ftpState->pathcomps)
1461 ftpTraverseDirectory(ftpState);
1462 else
1463 ftpListDir(ftpState);
1464 } else {
1465 ftpFail(ftpState);
1466 }
1467 }
1468
1469 static void
1470 ftpTraverseDirectory(Ftp::Gateway * ftpState)
1471 {
1472 wordlist *w;
1473 debugs(9, 4, HERE << (ftpState->filepath ? ftpState->filepath : "<NULL>"));
1474
1475 safe_free(ftpState->dirpath);
1476 ftpState->dirpath = ftpState->filepath;
1477 ftpState->filepath = NULL;
1478
1479 /* Done? */
1480
1481 if (ftpState->pathcomps == NULL) {
1482 debugs(9, 3, HERE << "the final component was a directory");
1483 ftpListDir(ftpState);
1484 return;
1485 }
1486
1487 /* Go to next path component */
1488 w = ftpState->pathcomps;
1489
1490 ftpState->filepath = w->key;
1491
1492 ftpState->pathcomps = w->next;
1493
1494 delete w;
1495
1496 /* Check if we are to CWD or RETR */
1497 if (ftpState->pathcomps != NULL || ftpState->flags.isdir) {
1498 ftpSendCwd(ftpState);
1499 } else {
1500 debugs(9, 3, HERE << "final component is probably a file");
1501 ftpGetFile(ftpState);
1502 return;
1503 }
1504 }
1505
1506 static void
1507 ftpSendCwd(Ftp::Gateway * ftpState)
1508 {
1509 char *path = NULL;
1510
1511 /* check the server control channel is still available */
1512 if (!ftpState || !ftpState->haveControlChannel("ftpSendCwd"))
1513 return;
1514
1515 debugs(9, 3, HERE);
1516
1517 path = ftpState->filepath;
1518
1519 if (!strcmp(path, "..") || !strcmp(path, "/")) {
1520 ftpState->flags.no_dotdot = 1;
1521 } else {
1522 ftpState->flags.no_dotdot = 0;
1523 }
1524
1525 snprintf(cbuf, CTRL_BUFLEN, "CWD %s\r\n", path);
1526
1527 ftpState->writeCommand(cbuf);
1528
1529 ftpState->state = Ftp::Client::SENT_CWD;
1530 }
1531
1532 static void
1533 ftpReadCwd(Ftp::Gateway * ftpState)
1534 {
1535 int code = ftpState->ctrl.replycode;
1536 debugs(9, 3, HERE);
1537
1538 if (code >= 200 && code < 300) {
1539 /* CWD OK */
1540 ftpState->unhack();
1541
1542 /* Reset cwd_message to only include the last message */
1543 ftpState->cwd_message.reset("");
1544 for (wordlist *w = ftpState->ctrl.message; w; w = w->next) {
1545 ftpState->cwd_message.append(' ');
1546 ftpState->cwd_message.append(w->key);
1547 }
1548 ftpState->ctrl.message = NULL;
1549
1550 /* Continue to traverse the path */
1551 ftpTraverseDirectory(ftpState);
1552 } else {
1553 /* CWD FAILED */
1554
1555 if (!ftpState->flags.put)
1556 ftpFail(ftpState);
1557 else
1558 ftpSendMkdir(ftpState);
1559 }
1560 }
1561
1562 static void
1563 ftpSendMkdir(Ftp::Gateway * ftpState)
1564 {
1565 char *path = NULL;
1566
1567 /* check the server control channel is still available */
1568 if (!ftpState || !ftpState->haveControlChannel("ftpSendMkdir"))
1569 return;
1570
1571 path = ftpState->filepath;
1572 debugs(9, 3, HERE << "with path=" << path);
1573 snprintf(cbuf, CTRL_BUFLEN, "MKD %s\r\n", path);
1574 ftpState->writeCommand(cbuf);
1575 ftpState->state = Ftp::Client::SENT_MKDIR;
1576 }
1577
1578 static void
1579 ftpReadMkdir(Ftp::Gateway * ftpState)
1580 {
1581 char *path = ftpState->filepath;
1582 int code = ftpState->ctrl.replycode;
1583
1584 debugs(9, 3, HERE << "path " << path << ", code " << code);
1585
1586 if (code == 257) { /* success */
1587 ftpSendCwd(ftpState);
1588 } else if (code == 550) { /* dir exists */
1589
1590 if (ftpState->flags.put_mkdir) {
1591 ftpState->flags.put_mkdir = 1;
1592 ftpSendCwd(ftpState);
1593 } else
1594 ftpSendReply(ftpState);
1595 } else
1596 ftpSendReply(ftpState);
1597 }
1598
1599 static void
1600 ftpGetFile(Ftp::Gateway * ftpState)
1601 {
1602 assert(*ftpState->filepath != '\0');
1603 ftpState->flags.isdir = 0;
1604 ftpSendMdtm(ftpState);
1605 }
1606
1607 static void
1608 ftpListDir(Ftp::Gateway * ftpState)
1609 {
1610 if (ftpState->flags.dir_slash) {
1611 debugs(9, 3, HERE << "Directory path did not end in /");
1612 ftpState->title_url.append("/");
1613 ftpState->flags.isdir = 1;
1614 }
1615
1616 ftpSendPassive(ftpState);
1617 }
1618
1619 static void
1620 ftpSendMdtm(Ftp::Gateway * ftpState)
1621 {
1622 /* check the server control channel is still available */
1623 if (!ftpState || !ftpState->haveControlChannel("ftpSendMdtm"))
1624 return;
1625
1626 assert(*ftpState->filepath != '\0');
1627 snprintf(cbuf, CTRL_BUFLEN, "MDTM %s\r\n", ftpState->filepath);
1628 ftpState->writeCommand(cbuf);
1629 ftpState->state = Ftp::Client::SENT_MDTM;
1630 }
1631
1632 static void
1633 ftpReadMdtm(Ftp::Gateway * ftpState)
1634 {
1635 int code = ftpState->ctrl.replycode;
1636 debugs(9, 3, HERE);
1637
1638 if (code == 213) {
1639 ftpState->mdtm = parse_iso3307_time(ftpState->ctrl.last_reply);
1640 ftpState->unhack();
1641 } else if (code < 0) {
1642 ftpFail(ftpState);
1643 return;
1644 }
1645
1646 ftpSendSize(ftpState);
1647 }
1648
1649 static void
1650 ftpSendSize(Ftp::Gateway * ftpState)
1651 {
1652 /* check the server control channel is still available */
1653 if (!ftpState || !ftpState->haveControlChannel("ftpSendSize"))
1654 return;
1655
1656 /* Only send SIZE for binary transfers. The returned size
1657 * is useless on ASCII transfers */
1658
1659 if (ftpState->flags.binary) {
1660 assert(ftpState->filepath != NULL);
1661 assert(*ftpState->filepath != '\0');
1662 snprintf(cbuf, CTRL_BUFLEN, "SIZE %s\r\n", ftpState->filepath);
1663 ftpState->writeCommand(cbuf);
1664 ftpState->state = Ftp::Client::SENT_SIZE;
1665 } else
1666 /* Skip to next state no non-binary transfers */
1667 ftpSendPassive(ftpState);
1668 }
1669
1670 static void
1671 ftpReadSize(Ftp::Gateway * ftpState)
1672 {
1673 int code = ftpState->ctrl.replycode;
1674 debugs(9, 3, HERE);
1675
1676 if (code == 213) {
1677 ftpState->unhack();
1678 ftpState->theSize = strtoll(ftpState->ctrl.last_reply, NULL, 10);
1679
1680 if (ftpState->theSize == 0) {
1681 debugs(9, 2, "SIZE reported " <<
1682 ftpState->ctrl.last_reply << " on " <<
1683 ftpState->title_url);
1684 ftpState->theSize = -1;
1685 }
1686 } else if (code < 0) {
1687 ftpFail(ftpState);
1688 return;
1689 }
1690
1691 ftpSendPassive(ftpState);
1692 }
1693
1694 static void
1695 ftpReadEPSV(Ftp::Gateway* ftpState)
1696 {
1697 Ip::Address srvAddr; // unused
1698 if (ftpState->handleEpsvReply(srvAddr)) {
1699 if (ftpState->ctrl.message == NULL)
1700 return; // didn't get complete reply yet
1701
1702 ftpState->connectDataChannel();
1703 }
1704 }
1705
1706 /** Send Passive connection request.
1707 * Default method is to use modern EPSV request.
1708 * The failover mechanism should check for previous state and re-call with alternates on failure.
1709 */
1710 static void
1711 ftpSendPassive(Ftp::Gateway * ftpState)
1712 {
1713 /** Checks the server control channel is still available before running. */
1714 if (!ftpState || !ftpState->haveControlChannel("ftpSendPassive"))
1715 return;
1716
1717 debugs(9, 3, HERE);
1718
1719 /** \par
1720 * Checks for 'HEAD' method request and passes off for special handling by Ftp::Gateway::processHeadResponse(). */
1721 if (ftpState->request->method == Http::METHOD_HEAD && (ftpState->flags.isdir || ftpState->theSize != -1)) {
1722 ftpState->processHeadResponse(); // may call serverComplete
1723 return;
1724 }
1725
1726 if (ftpState->sendPassive()) {
1727 // SENT_EPSV_ALL blocks other non-EPSV connections being attempted
1728 if (ftpState->state == Ftp::Client::SENT_EPSV_ALL)
1729 ftpState->flags.epsv_all_sent = true;
1730 }
1731 }
1732
1733 void
1734 Ftp::Gateway::processHeadResponse()
1735 {
1736 debugs(9, 5, HERE << "handling HEAD response");
1737 ftpSendQuit(this);
1738 appendSuccessHeader();
1739
1740 /*
1741 * On rare occasions I'm seeing the entry get aborted after
1742 * readControlReply() and before here, probably when
1743 * trying to write to the client.
1744 */
1745 if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1746 abortTransaction("entry aborted while processing HEAD");
1747 return;
1748 }
1749
1750 #if USE_ADAPTATION
1751 if (adaptationAccessCheckPending) {
1752 debugs(9,3, HERE << "returning due to adaptationAccessCheckPending");
1753 return;
1754 }
1755 #endif
1756
1757 // processReplyBody calls serverComplete() since there is no body
1758 processReplyBody();
1759 }
1760
1761 static void
1762 ftpReadPasv(Ftp::Gateway * ftpState)
1763 {
1764 Ip::Address srvAddr; // unused
1765 if (ftpState->handlePasvReply(srvAddr))
1766 ftpState->connectDataChannel();
1767 else {
1768 ftpSendEPRT(ftpState);
1769 return;
1770 }
1771 }
1772
1773 void
1774 Ftp::Gateway::dataChannelConnected(const CommConnectCbParams &io)
1775 {
1776 debugs(9, 3, HERE);
1777 data.opener = NULL;
1778
1779 if (io.flag != Comm::OK) {
1780 debugs(9, 2, HERE << "Failed to connect. Retrying via another method.");
1781
1782 // ABORT on timeouts. server may be waiting on a broken TCP link.
1783 if (io.xerrno == Comm::TIMEOUT)
1784 writeCommand("ABOR");
1785
1786 // try another connection attempt with some other method
1787 ftpSendPassive(this);
1788 return;
1789 }
1790
1791 data.opened(io.conn, dataCloser());
1792 ftpRestOrList(this);
1793 }
1794
1795 static void
1796 ftpOpenListenSocket(Ftp::Gateway * ftpState, int fallback)
1797 {
1798 /// Close old data channels, if any. We may open a new one below.
1799 if (ftpState->data.conn != NULL) {
1800 if ((ftpState->data.conn->flags & COMM_REUSEADDR))
1801 // NP: in fact it points to the control channel. just clear it.
1802 ftpState->data.clear();
1803 else
1804 ftpState->data.close();
1805 }
1806 safe_free(ftpState->data.host);
1807
1808 /*
1809 * Set up a listen socket on the same local address as the
1810 * control connection.
1811 */
1812 Comm::ConnectionPointer temp = new Comm::Connection;
1813 temp->local = ftpState->ctrl.conn->local;
1814
1815 /*
1816 * REUSEADDR is needed in fallback mode, since the same port is
1817 * used for both control and data.
1818 */
1819 if (fallback) {
1820 int on = 1;
1821 setsockopt(ftpState->ctrl.conn->fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on));
1822 ftpState->ctrl.conn->flags |= COMM_REUSEADDR;
1823 temp->flags |= COMM_REUSEADDR;
1824 } else {
1825 /* if not running in fallback mode a new port needs to be retrieved */
1826 temp->local.port(0);
1827 }
1828
1829 ftpState->listenForDataChannel(temp);
1830 }
1831
1832 static void
1833 ftpSendPORT(Ftp::Gateway * ftpState)
1834 {
1835 /* check the server control channel is still available */
1836 if (!ftpState || !ftpState->haveControlChannel("ftpSendPort"))
1837 return;
1838
1839 if (Config.Ftp.epsv_all && ftpState->flags.epsv_all_sent) {
1840 debugs(9, DBG_IMPORTANT, "FTP does not allow PORT method after 'EPSV ALL' has been sent.");
1841 return;
1842 }
1843
1844 debugs(9, 3, HERE);
1845 ftpState->flags.pasv_supported = 0;
1846 ftpOpenListenSocket(ftpState, 0);
1847
1848 if (!Comm::IsConnOpen(ftpState->data.listenConn)) {
1849 if ( ftpState->data.listenConn != NULL && !ftpState->data.listenConn->local.isIPv4() ) {
1850 /* non-IPv4 CANNOT send PORT command. */
1851 /* we got here by attempting and failing an EPRT */
1852 /* using the same reply code should simulate a PORT failure */
1853 ftpReadPORT(ftpState);
1854 return;
1855 }
1856
1857 /* XXX Need to set error message */
1858 ftpFail(ftpState);
1859 return;
1860 }
1861
1862 // pull out the internal IP address bytes to send in PORT command...
1863 // source them from the listen_conn->local
1864
1865 struct addrinfo *AI = NULL;
1866 ftpState->data.listenConn->local.getAddrInfo(AI, AF_INET);
1867 unsigned char *addrptr = (unsigned char *) &((struct sockaddr_in*)AI->ai_addr)->sin_addr;
1868 unsigned char *portptr = (unsigned char *) &((struct sockaddr_in*)AI->ai_addr)->sin_port;
1869 snprintf(cbuf, CTRL_BUFLEN, "PORT %d,%d,%d,%d,%d,%d\r\n",
1870 addrptr[0], addrptr[1], addrptr[2], addrptr[3],
1871 portptr[0], portptr[1]);
1872 ftpState->writeCommand(cbuf);
1873 ftpState->state = Ftp::Client::SENT_PORT;
1874
1875 Ip::Address::FreeAddr(AI);
1876 }
1877
1878 static void
1879 ftpReadPORT(Ftp::Gateway * ftpState)
1880 {
1881 int code = ftpState->ctrl.replycode;
1882 debugs(9, 3, HERE);
1883
1884 if (code != 200) {
1885 /* Fall back on using the same port as the control connection */
1886 debugs(9, 3, "PORT not supported by remote end");
1887 ftpOpenListenSocket(ftpState, 1);
1888 }
1889
1890 ftpRestOrList(ftpState);
1891 }
1892
1893 static void
1894 ftpSendEPRT(Ftp::Gateway * ftpState)
1895 {
1896 if (Config.Ftp.epsv_all && ftpState->flags.epsv_all_sent) {
1897 debugs(9, DBG_IMPORTANT, "FTP does not allow EPRT method after 'EPSV ALL' has been sent.");
1898 return;
1899 }
1900
1901 if (!Config.Ftp.eprt) {
1902 /* Disabled. Switch immediately to attempting old PORT command. */
1903 debugs(9, 3, "EPRT disabled by local administrator");
1904 ftpSendPORT(ftpState);
1905 return;
1906 }
1907
1908 debugs(9, 3, HERE);
1909 ftpState->flags.pasv_supported = 0;
1910
1911 ftpOpenListenSocket(ftpState, 0);
1912 debugs(9, 3, "Listening for FTP data connection with FD " << ftpState->data.conn);
1913 if (!Comm::IsConnOpen(ftpState->data.conn)) {
1914 /* XXX Need to set error message */
1915 ftpFail(ftpState);
1916 return;
1917 }
1918
1919 char buf[MAX_IPSTRLEN];
1920
1921 /* RFC 2428 defines EPRT as IPv6 equivalent to IPv4 PORT command. */
1922 /* Which can be used by EITHER protocol. */
1923 snprintf(cbuf, CTRL_BUFLEN, "EPRT |%d|%s|%d|\r\n",
1924 ( ftpState->data.listenConn->local.isIPv6() ? 2 : 1 ),
1925 ftpState->data.listenConn->local.toStr(buf,MAX_IPSTRLEN),
1926 ftpState->data.listenConn->local.port() );
1927
1928 ftpState->writeCommand(cbuf);
1929 ftpState->state = Ftp::Client::SENT_EPRT;
1930 }
1931
1932 static void
1933 ftpReadEPRT(Ftp::Gateway * ftpState)
1934 {
1935 int code = ftpState->ctrl.replycode;
1936 debugs(9, 3, HERE);
1937
1938 if (code != 200) {
1939 /* Failover to attempting old PORT command. */
1940 debugs(9, 3, "EPRT not supported by remote end");
1941 ftpSendPORT(ftpState);
1942 return;
1943 }
1944
1945 ftpRestOrList(ftpState);
1946 }
1947
1948 /** "read" handler to accept FTP data connections.
1949 *
1950 \param io comm accept(2) callback parameters
1951 */
1952 void
1953 Ftp::Gateway::ftpAcceptDataConnection(const CommAcceptCbParams &io)
1954 {
1955 debugs(9, 3, HERE);
1956
1957 if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
1958 abortTransaction("entry aborted when accepting data conn");
1959 data.listenConn->close();
1960 data.listenConn = NULL;
1961 return;
1962 }
1963
1964 if (io.flag != Comm::OK) {
1965 data.listenConn->close();
1966 data.listenConn = NULL;
1967 debugs(9, DBG_IMPORTANT, "FTP AcceptDataConnection: " << io.conn << ": " << xstrerr(io.xerrno));
1968 /** \todo Need to send error message on control channel*/
1969 ftpFail(this);
1970 return;
1971 }
1972
1973 /* data listening conn is no longer even open. abort. */
1974 if (!Comm::IsConnOpen(data.listenConn)) {
1975 data.listenConn = NULL; // ensure that it's cleared and not just closed.
1976 return;
1977 }
1978
1979 /* data listening conn is no longer even open. abort. */
1980 if (!Comm::IsConnOpen(data.conn)) {
1981 data.clear(); // ensure that it's cleared and not just closed.
1982 return;
1983 }
1984
1985 /** \par
1986 * When squid.conf ftp_sanitycheck is enabled, check the new connection is actually being
1987 * made by the remote client which is connected to the FTP control socket.
1988 * Or the one which we were told to listen for by control channel messages (may differ under NAT).
1989 * This prevents third-party hacks, but also third-party load balancing handshakes.
1990 */
1991 if (Config.Ftp.sanitycheck) {
1992 // accept if either our data or ctrl connection is talking to this remote peer.
1993 if (data.conn->remote != io.conn->remote && ctrl.conn->remote != io.conn->remote) {
1994 debugs(9, DBG_IMPORTANT,
1995 "FTP data connection from unexpected server (" <<
1996 io.conn->remote << "), expecting " <<
1997 data.conn->remote << " or " << ctrl.conn->remote);
1998
1999 /* close the bad sources connection down ASAP. */
2000 io.conn->close();
2001
2002 /* drop the bad connection (io) by ignoring the attempt. */
2003 return;
2004 }
2005 }
2006
2007 /** On Comm::OK start using the accepted data socket and discard the temporary listen socket. */
2008 data.close();
2009 data.opened(io.conn, dataCloser());
2010 data.addr(io.conn->remote);
2011
2012 debugs(9, 3, HERE << "Connected data socket on " <<
2013 io.conn << ". FD table says: " <<
2014 "ctrl-peer= " << fd_table[ctrl.conn->fd].ipaddr << ", " <<
2015 "data-peer= " << fd_table[data.conn->fd].ipaddr);
2016
2017 assert(haveControlChannel("ftpAcceptDataConnection"));
2018 assert(ctrl.message == NULL);
2019
2020 // Ctrl channel operations will determine what happens to this data connection
2021 }
2022
2023 static void
2024 ftpRestOrList(Ftp::Gateway * ftpState)
2025 {
2026 debugs(9, 3, HERE);
2027
2028 if (ftpState->typecode == 'D') {
2029 ftpState->flags.isdir = 1;
2030
2031 if (ftpState->flags.put) {
2032 ftpSendMkdir(ftpState); /* PUT name;type=d */
2033 } else {
2034 ftpSendNlst(ftpState); /* GET name;type=d sec 3.2.2 of RFC 1738 */
2035 }
2036 } else if (ftpState->flags.put) {
2037 ftpSendStor(ftpState);
2038 } else if (ftpState->flags.isdir)
2039 ftpSendList(ftpState);
2040 else if (ftpState->restartable())
2041 ftpSendRest(ftpState);
2042 else
2043 ftpSendRetr(ftpState);
2044 }
2045
2046 static void
2047 ftpSendStor(Ftp::Gateway * ftpState)
2048 {
2049 /* check the server control channel is still available */
2050 if (!ftpState || !ftpState->haveControlChannel("ftpSendStor"))
2051 return;
2052
2053 debugs(9, 3, HERE);
2054
2055 if (ftpState->filepath != NULL) {
2056 /* Plain file upload */
2057 snprintf(cbuf, CTRL_BUFLEN, "STOR %s\r\n", ftpState->filepath);
2058 ftpState->writeCommand(cbuf);
2059 ftpState->state = Ftp::Client::SENT_STOR;
2060 } else if (ftpState->request->header.getInt64(HDR_CONTENT_LENGTH) > 0) {
2061 /* File upload without a filename. use STOU to generate one */
2062 snprintf(cbuf, CTRL_BUFLEN, "STOU\r\n");
2063 ftpState->writeCommand(cbuf);
2064 ftpState->state = Ftp::Client::SENT_STOR;
2065 } else {
2066 /* No file to transfer. Only create directories if needed */
2067 ftpSendReply(ftpState);
2068 }
2069 }
2070
2071 /// \deprecated use ftpState->readStor() instead.
2072 static void
2073 ftpReadStor(Ftp::Gateway * ftpState)
2074 {
2075 ftpState->readStor();
2076 }
2077
2078 void Ftp::Gateway::readStor()
2079 {
2080 int code = ctrl.replycode;
2081 debugs(9, 3, HERE);
2082
2083 if (code == 125 || (code == 150 && Comm::IsConnOpen(data.conn))) {
2084 if (!originalRequest()->body_pipe) {
2085 debugs(9, 3, "zero-size STOR?");
2086 state = WRITING_DATA; // make ftpWriteTransferDone() responsible
2087 dataComplete(); // XXX: keep in sync with doneSendingRequestBody()
2088 return;
2089 }
2090
2091 if (!startRequestBodyFlow()) { // register to receive body data
2092 ftpFail(this);
2093 return;
2094 }
2095
2096 /* When client status is 125, or 150 and the data connection is open, Begin data transfer. */
2097 debugs(9, 3, HERE << "starting data transfer");
2098 switchTimeoutToDataChannel();
2099 sendMoreRequestBody();
2100 fwd->dontRetry(true); // dont permit re-trying if the body was sent.
2101 state = WRITING_DATA;
2102 debugs(9, 3, HERE << "writing data channel");
2103 } else if (code == 150) {
2104 /* When client code is 150 with no data channel, Accept data channel. */
2105 debugs(9, 3, "ftpReadStor: accepting data channel");
2106 listenForDataChannel(data.conn);
2107 } else {
2108 debugs(9, DBG_IMPORTANT, HERE << "Unexpected reply code "<< std::setfill('0') << std::setw(3) << code);
2109 ftpFail(this);
2110 }
2111 }
2112
2113 static void
2114 ftpSendRest(Ftp::Gateway * ftpState)
2115 {
2116 /* check the server control channel is still available */
2117 if (!ftpState || !ftpState->haveControlChannel("ftpSendRest"))
2118 return;
2119
2120 debugs(9, 3, HERE);
2121
2122 snprintf(cbuf, CTRL_BUFLEN, "REST %" PRId64 "\r\n", ftpState->restart_offset);
2123 ftpState->writeCommand(cbuf);
2124 ftpState->state = Ftp::Client::SENT_REST;
2125 }
2126
2127 int
2128 Ftp::Gateway::restartable()
2129 {
2130 if (restart_offset > 0)
2131 return 1;
2132
2133 if (!request->range)
2134 return 0;
2135
2136 if (!flags.binary)
2137 return 0;
2138
2139 if (theSize <= 0)
2140 return 0;
2141
2142 int64_t desired_offset = request->range->lowestOffset(theSize);
2143
2144 if (desired_offset <= 0)
2145 return 0;
2146
2147 if (desired_offset >= theSize)
2148 return 0;
2149
2150 restart_offset = desired_offset;
2151 return 1;
2152 }
2153
2154 static void
2155 ftpReadRest(Ftp::Gateway * ftpState)
2156 {
2157 int code = ftpState->ctrl.replycode;
2158 debugs(9, 3, HERE);
2159 assert(ftpState->restart_offset > 0);
2160
2161 if (code == 350) {
2162 ftpState->setCurrentOffset(ftpState->restart_offset);
2163 ftpSendRetr(ftpState);
2164 } else if (code > 0) {
2165 debugs(9, 3, HERE << "REST not supported");
2166 ftpState->flags.rest_supported = 0;
2167 ftpSendRetr(ftpState);
2168 } else {
2169 ftpFail(ftpState);
2170 }
2171 }
2172
2173 static void
2174 ftpSendList(Ftp::Gateway * ftpState)
2175 {
2176 /* check the server control channel is still available */
2177 if (!ftpState || !ftpState->haveControlChannel("ftpSendList"))
2178 return;
2179
2180 debugs(9, 3, HERE);
2181
2182 if (ftpState->filepath) {
2183 snprintf(cbuf, CTRL_BUFLEN, "LIST %s\r\n", ftpState->filepath);
2184 } else {
2185 snprintf(cbuf, CTRL_BUFLEN, "LIST\r\n");
2186 }
2187
2188 ftpState->writeCommand(cbuf);
2189 ftpState->state = Ftp::Client::SENT_LIST;
2190 }
2191
2192 static void
2193 ftpSendNlst(Ftp::Gateway * ftpState)
2194 {
2195 /* check the server control channel is still available */
2196 if (!ftpState || !ftpState->haveControlChannel("ftpSendNlst"))
2197 return;
2198
2199 debugs(9, 3, HERE);
2200
2201 ftpState->flags.tried_nlst = 1;
2202
2203 if (ftpState->filepath) {
2204 snprintf(cbuf, CTRL_BUFLEN, "NLST %s\r\n", ftpState->filepath);
2205 } else {
2206 snprintf(cbuf, CTRL_BUFLEN, "NLST\r\n");
2207 }
2208
2209 ftpState->writeCommand(cbuf);
2210 ftpState->state = Ftp::Client::SENT_NLST;
2211 }
2212
2213 static void
2214 ftpReadList(Ftp::Gateway * ftpState)
2215 {
2216 int code = ftpState->ctrl.replycode;
2217 debugs(9, 3, HERE);
2218
2219 if (code == 125 || (code == 150 && Comm::IsConnOpen(ftpState->data.conn))) {
2220 /* Begin data transfer */
2221 debugs(9, 3, HERE << "begin data transfer from " << ftpState->data.conn->remote << " (" << ftpState->data.conn->local << ")");
2222 ftpState->switchTimeoutToDataChannel();
2223 ftpState->maybeReadVirginBody();
2224 ftpState->state = Ftp::Client::READING_DATA;
2225 return;
2226 } else if (code == 150) {
2227 /* Accept data channel */
2228 debugs(9, 3, HERE << "accept data channel from " << ftpState->data.conn->remote << " (" << ftpState->data.conn->local << ")");
2229 ftpState->listenForDataChannel(ftpState->data.conn);
2230 return;
2231 } else if (!ftpState->flags.tried_nlst && code > 300) {
2232 ftpSendNlst(ftpState);
2233 } else {
2234 ftpFail(ftpState);
2235 return;
2236 }
2237 }
2238
2239 static void
2240 ftpSendRetr(Ftp::Gateway * ftpState)
2241 {
2242 /* check the server control channel is still available */
2243 if (!ftpState || !ftpState->haveControlChannel("ftpSendRetr"))
2244 return;
2245
2246 debugs(9, 3, HERE);
2247
2248 assert(ftpState->filepath != NULL);
2249 snprintf(cbuf, CTRL_BUFLEN, "RETR %s\r\n", ftpState->filepath);
2250 ftpState->writeCommand(cbuf);
2251 ftpState->state = Ftp::Client::SENT_RETR;
2252 }
2253
2254 static void
2255 ftpReadRetr(Ftp::Gateway * ftpState)
2256 {
2257 int code = ftpState->ctrl.replycode;
2258 debugs(9, 3, HERE);
2259
2260 if (code == 125 || (code == 150 && Comm::IsConnOpen(ftpState->data.conn))) {
2261 /* Begin data transfer */
2262 debugs(9, 3, HERE << "begin data transfer from " << ftpState->data.conn->remote << " (" << ftpState->data.conn->local << ")");
2263 ftpState->switchTimeoutToDataChannel();
2264 ftpState->maybeReadVirginBody();
2265 ftpState->state = Ftp::Client::READING_DATA;
2266 } else if (code == 150) {
2267 /* Accept data channel */
2268 ftpState->listenForDataChannel(ftpState->data.conn);
2269 } else if (code >= 300) {
2270 if (!ftpState->flags.try_slash_hack) {
2271 /* Try this as a directory missing trailing slash... */
2272 ftpState->hackShortcut(ftpSendCwd);
2273 } else {
2274 ftpFail(ftpState);
2275 }
2276 } else {
2277 ftpFail(ftpState);
2278 }
2279 }
2280
2281 /**
2282 * Generate the HTTP headers and template fluff around an FTP
2283 * directory listing display.
2284 */
2285 void
2286 Ftp::Gateway::completedListing()
2287 {
2288 assert(entry);
2289 entry->lock("Ftp::Gateway");
2290 ErrorState ferr(ERR_DIR_LISTING, Http::scOkay, request);
2291 ferr.ftp.listing = &listing;
2292 ferr.ftp.cwd_msg = xstrdup(cwd_message.size()? cwd_message.termedBuf() : "");
2293 ferr.ftp.server_msg = ctrl.message;
2294 ctrl.message = NULL;
2295 entry->replaceHttpReply( ferr.BuildHttpReply() );
2296 EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
2297 entry->flush();
2298 entry->unlock("Ftp::Gateway");
2299 }
2300
2301 static void
2302 ftpReadTransferDone(Ftp::Gateway * ftpState)
2303 {
2304 int code = ftpState->ctrl.replycode;
2305 debugs(9, 3, HERE);
2306
2307 if (code == 226 || code == 250) {
2308 /* Connection closed; retrieval done. */
2309 if (ftpState->flags.listing) {
2310 ftpState->completedListing();
2311 /* QUIT operation handles sending the reply to client */
2312 }
2313 ftpSendQuit(ftpState);
2314 } else { /* != 226 */
2315 debugs(9, DBG_IMPORTANT, HERE << "Got code " << code << " after reading data");
2316 ftpState->failed(ERR_FTP_FAILURE, 0);
2317 /* failed closes ctrl.conn and frees ftpState */
2318 return;
2319 }
2320 }
2321
2322 // premature end of the request body
2323 void
2324 Ftp::Gateway::handleRequestBodyProducerAborted()
2325 {
2326 Client::handleRequestBodyProducerAborted();
2327 debugs(9, 3, HERE << "ftpState=" << this);
2328 failed(ERR_READ_ERROR, 0);
2329 }
2330
2331 static void
2332 ftpWriteTransferDone(Ftp::Gateway * ftpState)
2333 {
2334 int code = ftpState->ctrl.replycode;
2335 debugs(9, 3, HERE);
2336
2337 if (!(code == 226 || code == 250)) {
2338 debugs(9, DBG_IMPORTANT, HERE << "Got code " << code << " after sending data");
2339 ftpState->failed(ERR_FTP_PUT_ERROR, 0);
2340 return;
2341 }
2342
2343 ftpState->entry->timestampsSet(); /* XXX Is this needed? */
2344 ftpSendReply(ftpState);
2345 }
2346
2347 static void
2348 ftpSendQuit(Ftp::Gateway * ftpState)
2349 {
2350 /* check the server control channel is still available */
2351 if (!ftpState || !ftpState->haveControlChannel("ftpSendQuit"))
2352 return;
2353
2354 snprintf(cbuf, CTRL_BUFLEN, "QUIT\r\n");
2355 ftpState->writeCommand(cbuf);
2356 ftpState->state = Ftp::Client::SENT_QUIT;
2357 }
2358
2359 /** Completes a client FTP operation with success or other page
2360 * generated and stored in the entry field by the code issuing QUIT.
2361 */
2362 static void
2363 ftpReadQuit(Ftp::Gateway * ftpState)
2364 {
2365 ftpState->serverComplete();
2366 }
2367
2368 static void
2369 ftpTrySlashHack(Ftp::Gateway * ftpState)
2370 {
2371 char *path;
2372 ftpState->flags.try_slash_hack = 1;
2373 /* Free old paths */
2374
2375 debugs(9, 3, HERE);
2376
2377 if (ftpState->pathcomps)
2378 wordlistDestroy(&ftpState->pathcomps);
2379
2380 safe_free(ftpState->filepath);
2381
2382 /* Build the new path (urlpath begins with /) */
2383 path = xstrdup(ftpState->request->urlpath.termedBuf());
2384
2385 rfc1738_unescape(path);
2386
2387 ftpState->filepath = path;
2388
2389 /* And off we go */
2390 ftpGetFile(ftpState);
2391 }
2392
2393 /**
2394 * Forget hack status. Next error is shown to the user
2395 */
2396 void
2397 Ftp::Gateway::unhack()
2398 {
2399 debugs(9, 3, HERE);
2400
2401 if (old_request != NULL) {
2402 safe_free(old_request);
2403 safe_free(old_reply);
2404 }
2405 }
2406
2407 void
2408 Ftp::Gateway::hackShortcut(FTPSM * nextState)
2409 {
2410 /* Clear some unwanted state */
2411 setCurrentOffset(0);
2412 restart_offset = 0;
2413 /* Save old error message & some state info */
2414
2415 debugs(9, 3, HERE);
2416
2417 if (old_request == NULL) {
2418 old_request = ctrl.last_command;
2419 ctrl.last_command = NULL;
2420 old_reply = ctrl.last_reply;
2421 ctrl.last_reply = NULL;
2422
2423 if (pathcomps == NULL && filepath != NULL)
2424 old_filepath = xstrdup(filepath);
2425 }
2426
2427 /* Jump to the "hack" state */
2428 nextState(this);
2429 }
2430
2431 static void
2432 ftpFail(Ftp::Gateway *ftpState)
2433 {
2434 debugs(9, 6, HERE << "flags(" <<
2435 (ftpState->flags.isdir?"IS_DIR,":"") <<
2436 (ftpState->flags.try_slash_hack?"TRY_SLASH_HACK":"") << "), " <<
2437 "mdtm=" << ftpState->mdtm << ", size=" << ftpState->theSize <<
2438 "slashhack=" << (ftpState->request->urlpath.caseCmp("/%2f", 4)==0? "T":"F") );
2439
2440 /* Try the / hack to support "Netscape" FTP URL's for retreiving files */
2441 if (!ftpState->flags.isdir && /* Not a directory */
2442 !ftpState->flags.try_slash_hack && /* Not in slash hack */
2443 ftpState->mdtm <= 0 && ftpState->theSize < 0 && /* Not known as a file */
2444 ftpState->request->urlpath.caseCmp("/%2f", 4) != 0) { /* No slash encoded */
2445
2446 switch (ftpState->state) {
2447
2448 case Ftp::Client::SENT_CWD:
2449
2450 case Ftp::Client::SENT_RETR:
2451 /* Try the / hack */
2452 ftpState->hackShortcut(ftpTrySlashHack);
2453 return;
2454
2455 default:
2456 break;
2457 }
2458 }
2459
2460 ftpState->failed(ERR_NONE, 0);
2461 /* failed() closes ctrl.conn and frees this */
2462 }
2463
2464 Http::StatusCode
2465 Ftp::Gateway::failedHttpStatus(err_type &error)
2466 {
2467 if (error == ERR_NONE) {
2468 switch (state) {
2469
2470 case SENT_USER:
2471
2472 case SENT_PASS:
2473
2474 if (ctrl.replycode > 500) {
2475 error = ERR_FTP_FORBIDDEN;
2476 return password_url ? Http::scForbidden : Http::scUnauthorized;
2477 } else if (ctrl.replycode == 421) {
2478 error = ERR_FTP_UNAVAILABLE;
2479 return Http::scServiceUnavailable;
2480 }
2481 break;
2482
2483 case SENT_CWD:
2484
2485 case SENT_RETR:
2486 if (ctrl.replycode == 550) {
2487 error = ERR_FTP_NOT_FOUND;
2488 return Http::scNotFound;
2489 }
2490 break;
2491
2492 default:
2493 break;
2494 }
2495 }
2496 return Ftp::Client::failedHttpStatus(error);
2497 }
2498
2499 static void
2500 ftpSendReply(Ftp::Gateway * ftpState)
2501 {
2502 int code = ftpState->ctrl.replycode;
2503 Http::StatusCode http_code;
2504 err_type err_code = ERR_NONE;
2505
2506 debugs(9, 3, HERE << ftpState->entry->url() << ", code " << code);
2507
2508 if (cbdataReferenceValid(ftpState))
2509 debugs(9, 5, HERE << "ftpState (" << ftpState << ") is valid!");
2510
2511 if (code == 226 || code == 250) {
2512 err_code = (ftpState->mdtm > 0) ? ERR_FTP_PUT_MODIFIED : ERR_FTP_PUT_CREATED;
2513 http_code = (ftpState->mdtm > 0) ? Http::scAccepted : Http::scCreated;
2514 } else if (code == 227) {
2515 err_code = ERR_FTP_PUT_CREATED;
2516 http_code = Http::scCreated;
2517 } else {
2518 err_code = ERR_FTP_PUT_ERROR;
2519 http_code = Http::scInternalServerError;
2520 }
2521
2522 ErrorState err(err_code, http_code, ftpState->request);
2523
2524 if (ftpState->old_request)
2525 err.ftp.request = xstrdup(ftpState->old_request);
2526 else
2527 err.ftp.request = xstrdup(ftpState->ctrl.last_command);
2528
2529 if (ftpState->old_reply)
2530 err.ftp.reply = xstrdup(ftpState->old_reply);
2531 else if (ftpState->ctrl.last_reply)
2532 err.ftp.reply = xstrdup(ftpState->ctrl.last_reply);
2533 else
2534 err.ftp.reply = xstrdup("");
2535
2536 // TODO: interpret as FTP-specific error code
2537 err.detailError(code);
2538
2539 ftpState->entry->replaceHttpReply( err.BuildHttpReply() );
2540
2541 ftpSendQuit(ftpState);
2542 }
2543
2544 void
2545 Ftp::Gateway::appendSuccessHeader()
2546 {
2547 const char *mime_type = NULL;
2548 const char *mime_enc = NULL;
2549 String urlpath = request->urlpath;
2550 const char *filename = NULL;
2551 const char *t = NULL;
2552
2553 debugs(9, 3, HERE);
2554
2555 if (flags.http_header_sent)
2556 return;
2557
2558 HttpReply *reply = new HttpReply;
2559
2560 flags.http_header_sent = 1;
2561
2562 assert(entry->isEmpty());
2563
2564 EBIT_CLR(entry->flags, ENTRY_FWD_HDR_WAIT);
2565
2566 entry->buffer(); /* released when done processing current data payload */
2567
2568 filename = (t = urlpath.rpos('/')) ? t + 1 : urlpath.termedBuf();
2569
2570 if (flags.isdir) {
2571 mime_type = "text/html";
2572 } else {
2573 switch (typecode) {
2574
2575 case 'I':
2576 mime_type = "application/octet-stream";
2577 mime_enc = mimeGetContentEncoding(filename);
2578 break;
2579
2580 case 'A':
2581 mime_type = "text/plain";
2582 break;
2583
2584 default:
2585 mime_type = mimeGetContentType(filename);
2586 mime_enc = mimeGetContentEncoding(filename);
2587 break;
2588 }
2589 }
2590
2591 /* set standard stuff */
2592
2593 if (0 == getCurrentOffset()) {
2594 /* Full reply */
2595 reply->setHeaders(Http::scOkay, "Gatewaying", mime_type, theSize, mdtm, -2);
2596 } else if (theSize < getCurrentOffset()) {
2597 /*
2598 * DPW 2007-05-04
2599 * offset should not be larger than theSize. We should
2600 * not be seeing this condition any more because we'll only
2601 * send REST if we know the theSize and if it is less than theSize.
2602 */
2603 debugs(0,DBG_CRITICAL,HERE << "Whoops! " <<
2604 " current offset=" << getCurrentOffset() <<
2605 ", but theSize=" << theSize <<
2606 ". assuming full content response");
2607 reply->setHeaders(Http::scOkay, "Gatewaying", mime_type, theSize, mdtm, -2);
2608 } else {
2609 /* Partial reply */
2610 HttpHdrRangeSpec range_spec;
2611 range_spec.offset = getCurrentOffset();
2612 range_spec.length = theSize - getCurrentOffset();
2613 reply->setHeaders(Http::scPartialContent, "Gatewaying", mime_type, theSize - getCurrentOffset(), mdtm, -2);
2614 httpHeaderAddContRange(&reply->header, range_spec, theSize);
2615 }
2616
2617 /* additional info */
2618 if (mime_enc)
2619 reply->header.putStr(HDR_CONTENT_ENCODING, mime_enc);
2620
2621 setVirginReply(reply);
2622 adaptOrFinalizeReply();
2623 }
2624
2625 void
2626 Ftp::Gateway::haveParsedReplyHeaders()
2627 {
2628 Client::haveParsedReplyHeaders();
2629
2630 StoreEntry *e = entry;
2631
2632 e->timestampsSet();
2633
2634 if (flags.authenticated) {
2635 /*
2636 * Authenticated requests can't be cached.
2637 */
2638 e->release();
2639 } else if (!EBIT_TEST(e->flags, RELEASE_REQUEST) && !getCurrentOffset()) {
2640 e->setPublicKey();
2641 } else {
2642 e->release();
2643 }
2644 }
2645
2646 HttpReply *
2647 Ftp::Gateway::ftpAuthRequired(HttpRequest * request, const char *realm)
2648 {
2649 ErrorState err(ERR_CACHE_ACCESS_DENIED, Http::scUnauthorized, request);
2650 HttpReply *newrep = err.BuildHttpReply();
2651 #if HAVE_AUTH_MODULE_BASIC
2652 /* add Authenticate header */
2653 newrep->header.putAuth("Basic", realm);
2654 #endif
2655 return newrep;
2656 }
2657
2658 const char *
2659 Ftp::UrlWith2f(HttpRequest * request)
2660 {
2661 String newbuf = "%2f";
2662
2663 if (request->url.getScheme() != AnyP::PROTO_FTP)
2664 return NULL;
2665
2666 if ( request->urlpath[0]=='/' ) {
2667 newbuf.append(request->urlpath);
2668 request->urlpath.absorb(newbuf);
2669 safe_free(request->canonical);
2670 } else if ( !strncmp(request->urlpath.termedBuf(), "%2f", 3) ) {
2671 newbuf.append(request->urlpath.substr(1,request->urlpath.size()));
2672 request->urlpath.absorb(newbuf);
2673 safe_free(request->canonical);
2674 }
2675
2676 return urlCanonical(request);
2677 }
2678
2679 void
2680 Ftp::Gateway::printfReplyBody(const char *fmt, ...)
2681 {
2682 va_list args;
2683 va_start (args, fmt);
2684 static char buf[4096];
2685 buf[0] = '\0';
2686 vsnprintf(buf, 4096, fmt, args);
2687 writeReplyBody(buf, strlen(buf));
2688 va_end(args);
2689 }
2690
2691 /**
2692 * Call this when there is data from the origin server
2693 * which should be sent to either StoreEntry, or to ICAP...
2694 */
2695 void
2696 Ftp::Gateway::writeReplyBody(const char *dataToWrite, size_t dataLength)
2697 {
2698 debugs(9, 5, HERE << "writing " << dataLength << " bytes to the reply");
2699 addVirginReplyBody(dataToWrite, dataLength);
2700 }
2701
2702 /**
2703 * A hack to ensure we do not double-complete on the forward entry.
2704 *
2705 \todo Ftp::Gateway logic should probably be rewritten to avoid
2706 * double-completion or FwdState should be rewritten to allow it.
2707 */
2708 void
2709 Ftp::Gateway::completeForwarding()
2710 {
2711 if (fwd == NULL || flags.completed_forwarding) {
2712 debugs(9, 3, HERE << "completeForwarding avoids " <<
2713 "double-complete on FD " << ctrl.conn->fd << ", Data FD " << data.conn->fd <<
2714 ", this " << this << ", fwd " << fwd);
2715 return;
2716 }
2717
2718 flags.completed_forwarding = true;
2719 Client::completeForwarding();
2720 }
2721
2722 /**
2723 * Have we lost the FTP server control channel?
2724 *
2725 \retval true The server control channel is available.
2726 \retval false The server control channel is not available.
2727 */
2728 bool
2729 Ftp::Gateway::haveControlChannel(const char *caller_name) const
2730 {
2731 if (doneWithServer())
2732 return false;
2733
2734 /* doneWithServer() only checks BOTH channels are closed. */
2735 if (!Comm::IsConnOpen(ctrl.conn)) {
2736 debugs(9, DBG_IMPORTANT, "WARNING! FTP Server Control channel is closed, but Data channel still active.");
2737 debugs(9, 2, caller_name << ": attempted on a closed FTP channel.");
2738 return false;
2739 }
2740
2741 return true;
2742 }
2743
2744 bool
2745 Ftp::Gateway::mayReadVirginReplyBody() const
2746 {
2747 // TODO: Can we do what Ftp::Relay::mayReadVirginReplyBody() does instead?
2748 return !doneWithServer();
2749 }
2750
2751 AsyncJob::Pointer
2752 Ftp::StartGateway(FwdState *const fwdState)
2753 {
2754 return AsyncJob::Start(new Ftp::Gateway(fwdState));
2755 }
2756
Mirror of https://github.com/squid-cache/squid.git