2 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
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.
9 /* DEBUG: section 33 Transfer protocol servers */
12 #include "acl/FilledChecklist.h"
13 #include "base/CharacterSet.h"
15 #include "base/RefCount.h"
16 #include "base/Subscription.h"
17 #include "client_side_reply.h"
18 #include "client_side_request.h"
19 #include "clientStream.h"
20 #include "comm/ConnOpener.h"
21 #include "comm/Read.h"
22 #include "comm/TcpAcceptor.h"
23 #include "comm/Write.h"
24 #include "errorpage.h"
26 #include "ftp/Elements.h"
27 #include "ftp/Parsing.h"
29 #include "http/one/RequestParser.h"
30 #include "http/Stream.h"
31 #include "HttpHdrCc.h"
33 #include "ipc/FdNotes.h"
34 #include "parser/Tokenizer.h"
35 #include "servers/forward.h"
36 #include "servers/FtpServer.h"
37 #include "SquidConfig.h"
38 #include "StatCounters.h"
44 CBDATA_NAMESPACED_CLASS_INIT(Ftp
, Server
);
48 static void PrintReply(MemBuf
&mb
, const HttpReply
*reply
, const char *const prefix
= "");
49 static bool SupportedCommand(const SBuf
&name
);
50 static bool CommandHasPathParameter(const SBuf
&cmd
);
53 Ftp::Server::Server(const MasterXaction::Pointer
&xact
):
54 AsyncJob("Ftp::Server"),
56 master(new MasterState
),
67 waitingForOrigin(false),
68 originDataDownloadAbortedOnError(false)
70 flags
.readMore
= false; // we need to announce ourselves first
74 Ftp::Server::~Server()
76 closeDataConnection();
80 Ftp::Server::pipelinePrefetchMax() const
82 return 0; // no support for concurrent FTP requests
86 Ftp::Server::idleTimeout() const
88 return Config
.Timeout
.ftpClientIdle
;
94 ConnStateData::start();
97 char buf
[MAX_IPSTRLEN
];
98 clientConnection
->local
.toUrl(buf
, MAX_IPSTRLEN
);
101 debugs(33, 5, "FTP transparent URL: " << uri
);
104 writeEarlyReply(220, "Service ready");
107 /// schedules another data connection read if needed
109 Ftp::Server::maybeReadUploadData()
111 if (reader
!= nullptr)
114 const size_t availSpace
= sizeof(uploadBuf
) - uploadAvailSize
;
118 debugs(33, 4, dataConn
<< ": reading FTP data...");
120 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
121 reader
= JobCallback(33, 5, Dialer
, this, Ftp::Server::readUploadData
);
122 comm_read(dataConn
, uploadBuf
+ uploadAvailSize
, availSpace
,
126 /// react to the freshly parsed request
128 Ftp::Server::doProcessRequest()
130 // zero pipelinePrefetchMax() ensures that there is only parsed request
131 Must(pipeline
.count() == 1);
132 Http::StreamPointer context
= pipeline
.front();
133 Must(context
!= nullptr);
135 ClientHttpRequest
*const http
= context
->http
;
136 assert(http
!= nullptr);
138 HttpRequest
*const request
= http
->request
;
139 Must(http
->storeEntry() || request
);
140 const bool mayForward
= !http
->storeEntry() && handleRequest(request
);
142 if (http
->storeEntry() != nullptr) {
143 debugs(33, 4, "got an immediate response");
144 clientSetKeepaliveFlag(http
);
146 } else if (mayForward
) {
147 debugs(33, 4, "forwarding request to server side");
148 assert(http
->storeEntry() == nullptr);
149 clientProcessRequest(this, Http1::RequestParserPointer(), context
.getRaw());
151 debugs(33, 4, "will resume processing later");
156 Ftp::Server::processParsedRequest(Http::StreamPointer
&)
158 Must(pipeline
.count() == 1);
160 // Process FTP request asynchronously to make sure FTP
161 // data connection accept callback is fired first.
162 CallJobHere(33, 4, CbcPointer
<Server
>(this),
163 Ftp::Server
, doProcessRequest
);
166 /// imports more upload data from the data connection
168 Ftp::Server::readUploadData(const CommIoCbParams
&io
)
170 debugs(33, 5, io
.conn
<< " size " << io
.size
);
171 Must(reader
!= nullptr);
174 assert(Comm::IsConnOpen(dataConn
));
175 assert(io
.conn
->fd
== dataConn
->fd
);
177 if (io
.flag
== Comm::OK
&& bodyPipe
!= nullptr) {
179 statCounter
.client_http
.kbytes_in
+= io
.size
;
181 char *const current_buf
= uploadBuf
+ uploadAvailSize
;
182 if (io
.buf
!= current_buf
)
183 memmove(current_buf
, io
.buf
, io
.size
);
184 uploadAvailSize
+= io
.size
;
186 } else if (io
.size
== 0) {
187 debugs(33, 5, io
.conn
<< " closed");
188 closeDataConnection();
189 if (uploadAvailSize
<= 0)
190 finishDechunkingRequest(true);
192 } else { // not Comm::Flags::OK or unexpected read
193 debugs(33, 5, io
.conn
<< " closed");
194 closeDataConnection();
195 finishDechunkingRequest(false);
200 /// shovel upload data from the internal buffer to the body pipe if possible
202 Ftp::Server::shovelUploadData()
204 assert(bodyPipe
!= nullptr);
206 debugs(33, 5, "handling FTP request data for " << clientConnection
);
207 const size_t putSize
= bodyPipe
->putMoreData(uploadBuf
,
210 uploadAvailSize
-= putSize
;
211 if (uploadAvailSize
> 0)
212 memmove(uploadBuf
, uploadBuf
+ putSize
, uploadAvailSize
);
215 if (Comm::IsConnOpen(dataConn
))
216 maybeReadUploadData();
217 else if (uploadAvailSize
<= 0)
218 finishDechunkingRequest(true);
222 Ftp::Server::noteMoreBodySpaceAvailable(BodyPipe::Pointer
)
224 if (!isOpen()) // if we are closing, nothing to do
231 Ftp::Server::noteBodyConsumerAborted(BodyPipe::Pointer ptr
)
233 if (!isOpen()) // if we are closing, nothing to do
236 ConnStateData::noteBodyConsumerAborted(ptr
);
237 closeDataConnection();
240 /// accept a new FTP control connection and hand it to a dedicated Server
242 Ftp::Server::AcceptCtrlConnection(const CommAcceptCbParams
¶ms
)
246 // NP: it is possible the port was reconfigured when the call or accept() was queued.
248 if (params
.flag
!= Comm::OK
) {
249 // Its possible the call was still queued when the client disconnected
250 debugs(33, 2, params
.port
->listenConn
<< ": FTP accept failure: " << xstrerr(params
.xerrno
));
254 debugs(33, 4, params
.conn
<< ": accepted");
255 fd_note(params
.conn
->fd
, "client ftp connect");
257 const auto xact
= MasterXaction::MakePortful(params
.port
);
258 xact
->tcpClient
= params
.conn
;
260 AsyncJob::Start(new Server(xact
));
261 // XXX: do not abandon the MasterXaction object
265 Ftp::StartListening()
267 const auto savedContext
= CodeContext::Current();
268 for (AnyP::PortCfgPointer s
= FtpPortList
; s
!= nullptr; s
= s
->next
) {
269 CodeContext::Reset(s
);
270 if (MAXTCPLISTENPORTS
== NHttpSockets
) {
271 debugs(1, DBG_IMPORTANT
, "Ignoring ftp_port lines exceeding the" <<
272 " limit of " << MAXTCPLISTENPORTS
<< " ports.");
276 // direct new connections accepted by listenConn to Accept()
277 typedef CommCbFunPtrCallT
<CommAcceptCbPtrFun
> AcceptCall
;
278 RefCount
<AcceptCall
> subCall
= commCbCall(5, 5, "Ftp::Server::AcceptCtrlConnection",
279 CommAcceptCbPtrFun(Ftp::Server::AcceptCtrlConnection
,
280 CommAcceptCbParams(nullptr)));
281 clientStartListeningOn(s
, subCall
, Ipc::fdnFtpSocket
);
283 CodeContext::Reset(savedContext
);
289 const auto savedContext
= CodeContext::Current();
290 for (AnyP::PortCfgPointer s
= FtpPortList
; s
!= nullptr; s
= s
->next
) {
291 CodeContext::Reset(s
);
292 if (s
->listenConn
!= nullptr) {
293 debugs(1, DBG_IMPORTANT
, "Closing FTP port " << s
->listenConn
->local
);
294 s
->listenConn
->close();
295 s
->listenConn
= nullptr;
298 CodeContext::Reset(savedContext
);
302 Ftp::Server::notePeerConnection(Comm::ConnectionPointer conn
)
305 Http::StreamPointer context
= pipeline
.front();
306 Must(context
!= nullptr);
307 ClientHttpRequest
*const http
= context
->http
;
308 Must(http
!= nullptr);
309 HttpRequest
*const request
= http
->request
;
310 Must(request
!= nullptr);
311 // make FTP peer connection exclusive to our request
312 pinBusyConnection(conn
, request
);
316 Ftp::Server::clientPinnedConnectionClosed(const CommCloseCbParams
&io
)
318 ConnStateData::clientPinnedConnectionClosed(io
);
320 // TODO: Keep the control connection open after fixing the reset
322 if (Comm::IsConnOpen(clientConnection
))
323 clientConnection
->close();
325 // TODO: If the server control connection is gone, reset state to login
326 // again. Resetting login alone is not enough: FtpRelay::sendCommand() will
327 // not re-login because FtpRelay::serverState() is not going to be
328 // fssConnected. Calling resetLogin() alone is also harmful because
329 // it does not reset correctly the client-to-squid control connection (eg
330 // respond if required with an error code, in all cases)
331 // resetLogin("control connection closure");
334 /// clear client and server login-related state after the old login is gone
336 Ftp::Server::resetLogin(const char *reason
)
338 debugs(33, 5, "will need to re-login due to " << reason
);
339 master
->clientReadGreeting
= false;
340 changeState(fssBegin
, reason
);
343 /// computes uri member from host and, if tracked, working dir with file name
345 Ftp::Server::calcUri(const SBuf
*file
)
347 // TODO: fill a class AnyP::Uri instead of string
350 if (port
->ftp_track_dirs
&& master
->workingDir
.length()) {
351 if (master
->workingDir
[0] != '/')
353 uri
.append(master
->workingDir
);
356 if (uri
[uri
.length() - 1] != '/')
359 if (port
->ftp_track_dirs
&& file
) {
360 static const CharacterSet
Slash("/", "/");
361 Parser::Tokenizer
tok(*file
);
363 uri
.append(tok
.remaining());
367 /// Starts waiting for a data connection. Returns listening port.
368 /// On errors, responds with an error and returns zero.
370 Ftp::Server::listenForDataConnection()
372 closeDataConnection();
374 Comm::ConnectionPointer conn
= new Comm::Connection
;
375 conn
->flags
= COMM_NONBLOCKING
;
376 conn
->local
= transparent() ? port
->s
: clientConnection
->local
;
378 const char *const note
= uri
.c_str();
379 comm_open_listener(SOCK_STREAM
, IPPROTO_TCP
, conn
, note
);
380 if (!Comm::IsConnOpen(conn
)) {
381 debugs(5, DBG_CRITICAL
, "ERROR: comm_open_listener failed for FTP data: " <<
382 conn
->local
<< " error: " << errno
);
383 writeCustomReply(451, "Internal error");
387 typedef CommCbMemFunT
<Server
, CommAcceptCbParams
> AcceptDialer
;
388 typedef AsyncCallT
<AcceptDialer
> AcceptCall
;
389 const auto call
= JobCallback(5, 5, AcceptDialer
, this, Ftp::Server::acceptDataConnection
);
390 Subscription::Pointer sub
= new CallSubscription
<AcceptCall
>(call
);
391 listener
= call
.getRaw();
392 dataListenConn
= conn
;
393 AsyncJob::Start(new Comm::TcpAcceptor(conn
, note
, sub
));
395 const unsigned int listeningPort
= comm_local_port(conn
->fd
);
396 conn
->local
.port(listeningPort
);
397 return listeningPort
;
401 Ftp::Server::acceptDataConnection(const CommAcceptCbParams
¶ms
)
403 if (params
.flag
!= Comm::OK
) {
404 // Its possible the call was still queued when the client disconnected
405 debugs(33, 2, dataListenConn
<< ": accept "
406 "failure: " << xstrerr(params
.xerrno
));
410 debugs(33, 4, "accepted " << params
.conn
);
411 fd_note(params
.conn
->fd
, "passive client ftp data");
413 if (!clientConnection
) {
414 debugs(33, 5, "late data connection?");
415 closeDataConnection(); // in case we are still listening
416 params
.conn
->close();
417 } else if (params
.conn
->remote
!= clientConnection
->remote
) {
418 debugs(33, 2, "rogue data conn? ctrl: " << clientConnection
->remote
);
419 params
.conn
->close();
420 // Some FTP servers close control connection here, but it may make
421 // things worse from DoS p.o.v. and no better from data stealing p.o.v.
423 closeDataConnection();
424 dataConn
= params
.conn
;
425 dataConn
->leaveOrphanage();
427 debugs(33, 7, "ready for data");
428 if (onDataAcceptCall
!= nullptr) {
429 AsyncCall::Pointer call
= onDataAcceptCall
;
430 onDataAcceptCall
= nullptr;
431 // If we got an upload request, start reading data from the client.
432 if (master
->serverState
== fssHandleUploadRequest
)
433 maybeReadUploadData();
435 Must(master
->serverState
== fssHandleDataRequest
);
438 mb
.appendf("150 Data connection opened.\r\n");
439 Comm::Write(clientConnection
, &mb
, call
);
445 Ftp::Server::closeDataConnection()
447 if (listener
!= nullptr) {
448 listener
->cancel("no longer needed");
452 if (Comm::IsConnOpen(dataListenConn
)) {
453 debugs(33, 5, "FTP closing client data listen socket: " <<
455 dataListenConn
->close();
457 dataListenConn
= nullptr;
459 if (reader
!= nullptr) {
460 // Comm::ReadCancel can deal with negative FDs
461 Comm::ReadCancel(dataConn
->fd
, reader
);
465 if (Comm::IsConnOpen(dataConn
)) {
466 debugs(33, 5, "FTP closing client data connection: " <<
473 /// Writes FTP [error] response before we fully parsed the FTP request and
474 /// created the corresponding HTTP request wrapper for that FTP request.
476 Ftp::Server::writeEarlyReply(const int code
, const char *msg
)
478 debugs(33, 7, code
<< ' ' << msg
);
479 assert(99 < code
&& code
< 1000);
483 mb
.appendf("%i %s\r\n", code
, msg
);
485 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
486 AsyncCall::Pointer call
= JobCallback(33, 5, Dialer
, this, Ftp::Server::wroteEarlyReply
);
487 Comm::Write(clientConnection
, &mb
, call
);
489 flags
.readMore
= false;
491 // TODO: Create master transaction. Log it in wroteEarlyReply().
495 Ftp::Server::writeReply(MemBuf
&mb
)
497 debugs(9, 2, "FTP Client " << clientConnection
);
498 debugs(9, 2, "FTP Client REPLY:\n---------\n" << mb
.buf
<<
501 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
502 AsyncCall::Pointer call
= JobCallback(33, 5, Dialer
, this, Ftp::Server::wroteReply
);
503 Comm::Write(clientConnection
, &mb
, call
);
507 Ftp::Server::writeCustomReply(const int code
, const char *msg
, const HttpReply
*reply
)
509 debugs(33, 7, code
<< ' ' << msg
);
510 assert(99 < code
&& code
< 1000);
512 const bool sendDetails
= reply
!= nullptr &&
513 reply
->header
.has(Http::HdrType::FTP_STATUS
) && reply
->header
.has(Http::HdrType::FTP_REASON
);
518 mb
.appendf("%i-%s\r\n", code
, msg
);
519 mb
.appendf(" Server reply:\r\n");
520 Ftp::PrintReply(mb
, reply
, " ");
521 mb
.appendf("%i \r\n", code
);
523 mb
.appendf("%i %s\r\n", code
, msg
);
529 Ftp::Server::changeState(const ServerState newState
, const char *reason
)
531 if (master
->serverState
== newState
) {
532 debugs(33, 3, "client state unchanged at " << master
->serverState
<<
533 " because " << reason
);
534 master
->serverState
= newState
;
536 debugs(33, 3, "client state was " << master
->serverState
<<
537 ", now " << newState
<< " because " << reason
);
538 master
->serverState
= newState
;
542 /// whether the given FTP command has a pathname parameter
544 Ftp::CommandHasPathParameter(const SBuf
&cmd
)
546 static std::set
<SBuf
> PathedCommands
;
547 if (!PathedCommands
.size()) {
548 PathedCommands
.insert(cmdMlst());
549 PathedCommands
.insert(cmdMlsd());
550 PathedCommands
.insert(cmdStat());
551 PathedCommands
.insert(cmdNlst());
552 PathedCommands
.insert(cmdList());
553 PathedCommands
.insert(cmdMkd());
554 PathedCommands
.insert(cmdRmd());
555 PathedCommands
.insert(cmdDele());
556 PathedCommands
.insert(cmdRnto());
557 PathedCommands
.insert(cmdRnfr());
558 PathedCommands
.insert(cmdAppe());
559 PathedCommands
.insert(cmdStor());
560 PathedCommands
.insert(cmdRetr());
561 PathedCommands
.insert(cmdSmnt());
562 PathedCommands
.insert(cmdCwd());
565 return PathedCommands
.find(cmd
) != PathedCommands
.end();
568 /// creates a context filled with an error message for a given early error
570 Ftp::Server::earlyError(const EarlyErrorKind eek
)
572 /* Default values, to be updated by the switch statement below */
574 const char *reason
= "Internal error";
575 const char *errUri
= "error:ftp-internal-early-error";
578 case EarlyErrorKind::HugeRequest
:
580 reason
= "Huge request";
581 errUri
= "error:ftp-huge-request";
584 case EarlyErrorKind::MissingLogin
:
586 reason
= "Must login first";
587 errUri
= "error:ftp-must-login-first";
590 case EarlyErrorKind::MissingUsername
:
592 reason
= "Missing username";
593 errUri
= "error:ftp-missing-username";
596 case EarlyErrorKind::MissingHost
:
598 reason
= "Missing host";
599 errUri
= "error:ftp-missing-host";
602 case EarlyErrorKind::UnsupportedCommand
:
604 reason
= "Unknown or unsupported command";
605 errUri
= "error:ftp-unsupported-command";
608 case EarlyErrorKind::InvalidUri
:
610 reason
= "Invalid URI";
611 errUri
= "error:ftp-invalid-uri";
614 case EarlyErrorKind::MalformedCommand
:
616 reason
= "Malformed command";
617 errUri
= "error:ftp-malformed-command";
620 // no default so that a compiler can check that we have covered all cases
623 Http::Stream
*context
= abortRequestParsing(errUri
);
624 clientStreamNode
*node
= context
->getClientReplyContext();
626 clientReplyContext
*repContext
= dynamic_cast<clientReplyContext
*>(node
->data
.getRaw());
629 // We cannot relay FTP scode/reason via HTTP-specific ErrorState.
630 // TODO: When/if ErrorState can handle native FTP errors, use it instead.
631 HttpReply
*reply
= Ftp::HttpReplyWrapper(scode
, reason
, Http::scBadRequest
, -1);
632 repContext
->setReplyToReply(reply
);
636 /// Parses a single FTP request on the control connection.
637 /// Returns a new Http::Stream on valid requests and all errors.
638 /// Returns NULL on incomplete requests that may still succeed given more data.
640 Ftp::Server::parseOneRequest()
642 flags
.readMore
= false; // common for all but one case below
644 // OWS <command> [ RWS <parameter> ] OWS LF
646 // InlineSpaceChars are isspace(3) or RFC 959 Section 3.1.1.5.2, except
647 // for the LF character that we must exclude here (but see FullWhiteSpace).
648 static const char * const InlineSpaceChars
= " \f\r\t\v";
649 static const CharacterSet InlineSpace
= CharacterSet("Ftp::Inline", InlineSpaceChars
);
650 static const CharacterSet FullWhiteSpace
= (InlineSpace
+ CharacterSet::LF
).rename("Ftp::FWS");
651 static const CharacterSet CommandChars
= FullWhiteSpace
.complement("Ftp::Command");
652 static const CharacterSet TailChars
= CharacterSet::LF
.complement("Ftp::Tail");
654 // This set is used to ignore empty commands without allowing an attacker
655 // to keep us endlessly busy by feeding us whitespace or empty commands.
656 static const CharacterSet
&LeadingSpace
= FullWhiteSpace
;
661 Parser::Tokenizer
tok(inBuf
);
663 (void)tok
.skipAll(LeadingSpace
); // leading OWS and empty commands
664 const bool parsed
= tok
.prefix(cmd
, CommandChars
); // required command
666 // note that the condition below will eat either RWS or trailing OWS
667 if (parsed
&& tok
.skipAll(InlineSpace
) && tok
.prefix(params
, TailChars
)) {
668 // now params may include trailing OWS
669 // TODO: Support right-trimming using CharacterSet in Tokenizer instead
670 static const SBuf
bufWhiteSpace(InlineSpaceChars
);
671 params
.trim(bufWhiteSpace
, false, true);
674 // Why limit command line and parameters size? Did not we just parse them?
675 // XXX: Our good old String cannot handle very long strings.
676 const SBuf::size_type tokenMax
= min(
677 static_cast<SBuf::size_type
>(32*1024), // conservative
678 static_cast<SBuf::size_type
>(Config
.maxRequestHeaderSize
));
679 if (cmd
.length() > tokenMax
|| params
.length() > tokenMax
) {
680 changeState(fssError
, "huge req token");
681 quitAfterError(nullptr);
682 return earlyError(EarlyErrorKind::HugeRequest
);
685 // technically, we may skip multiple NLs below, but that is OK
686 if (!parsed
|| !tok
.skipAll(CharacterSet::LF
)) { // did not find terminating LF yet
687 // we need more data, but can we buffer more?
688 if (inBuf
.length() >= Config
.maxRequestHeaderSize
) {
689 changeState(fssError
, "huge req");
690 quitAfterError(nullptr);
691 return earlyError(EarlyErrorKind::HugeRequest
);
693 flags
.readMore
= true;
694 debugs(33, 5, "Waiting for more, up to " <<
695 (Config
.maxRequestHeaderSize
- inBuf
.length()));
700 Must(parsed
&& cmd
.length());
701 consumeInput(tok
.parsedSize()); // TODO: Would delaying optimize copying?
703 debugs(33, 2, ">>ftp " << cmd
<< (params
.isEmpty() ? "" : " ") << params
);
705 cmd
.toUpper(); // this should speed up and simplify future comparisons
707 // interception cases do not need USER to calculate the uri
708 if (!transparent()) {
709 if (!master
->clientReadGreeting
) {
710 // the first command must be USER
711 if (!pinning
.pinned
&& cmd
!= cmdUser())
712 return earlyError(EarlyErrorKind::MissingLogin
);
715 // process USER request now because it sets FTP peer host name
716 if (cmd
== cmdUser()) {
717 if (Http::Stream
*errCtx
= handleUserRequest(cmd
, params
))
722 if (!Ftp::SupportedCommand(cmd
))
723 return earlyError(EarlyErrorKind::UnsupportedCommand
);
725 const HttpRequestMethod method
=
726 cmd
== cmdAppe() || cmd
== cmdStor() || cmd
== cmdStou() ?
727 Http::METHOD_PUT
: Http::METHOD_GET
;
729 const SBuf
*path
= (params
.length() && CommandHasPathParameter(cmd
)) ?
732 const auto mx
= MasterXaction::MakePortful(port
);
733 mx
->tcpClient
= clientConnection
;
734 auto * const request
= HttpRequest::FromUrl(uri
, mx
, method
);
736 debugs(33, 5, "Invalid FTP URL: " << uri
);
738 return earlyError(EarlyErrorKind::InvalidUri
);
740 char *newUri
= xstrdup(uri
.c_str());
742 request
->flags
.ftpNative
= true;
743 request
->http_ver
= Http::ProtocolVersion(Ftp::ProtocolVersion().major
, Ftp::ProtocolVersion().minor
);
745 // Our fake Request-URIs are not distinctive enough for caching to work
746 request
->flags
.disableCacheUse("FTP command wrapper");
748 request
->header
.putStr(Http::HdrType::FTP_COMMAND
, cmd
.c_str());
749 request
->header
.putStr(Http::HdrType::FTP_ARGUMENTS
, params
.c_str()); // may be ""
750 if (method
== Http::METHOD_PUT
) {
751 request
->header
.putStr(Http::HdrType::EXPECT
, "100-continue");
752 request
->header
.putStr(Http::HdrType::TRANSFER_ENCODING
, "chunked");
755 ClientHttpRequest
*const http
= new ClientHttpRequest(this);
756 http
->req_sz
= tok
.parsedSize();
758 http
->initRequest(request
);
760 Http::Stream
*const result
=
761 new Http::Stream(clientConnection
, http
);
763 StoreIOBuffer tempBuffer
;
764 tempBuffer
.data
= result
->reqbuf
;
765 tempBuffer
.length
= HTTP_REQBUF_SZ
;
767 ClientStreamData newServer
= new clientReplyContext(http
);
768 ClientStreamData newClient
= result
;
769 clientStreamInit(&http
->client_stream
, clientGetMoreData
, clientReplyDetach
,
770 clientReplyStatus
, newServer
, clientSocketRecipient
,
771 clientSocketDetach
, newClient
, tempBuffer
);
773 result
->flags
.parsed_ok
= 1;
778 Ftp::Server::handleReply(HttpReply
*reply
, StoreIOBuffer data
)
780 // the caller guarantees that we are dealing with the current context only
781 Http::StreamPointer context
= pipeline
.front();
782 assert(context
!= nullptr);
784 static ReplyHandler handlers
[] = {
786 nullptr, // fssConnected
787 &Ftp::Server::handleFeatReply
, // fssHandleFeat
788 &Ftp::Server::handlePasvReply
, // fssHandlePasv
789 &Ftp::Server::handlePortReply
, // fssHandlePort
790 &Ftp::Server::handleDataReply
, // fssHandleDataRequest
791 &Ftp::Server::handleUploadReply
, // fssHandleUploadRequest
792 &Ftp::Server::handleEprtReply
,// fssHandleEprt
793 &Ftp::Server::handleEpsvReply
,// fssHandleEpsv
794 nullptr, // fssHandleCwd
795 nullptr, // fssHandlePass
796 nullptr, // fssHandleCdup
797 &Ftp::Server::handleErrorReply
// fssError
800 const Server
&server
= dynamic_cast<const Ftp::Server
&>(*context
->getConn());
801 if (const ReplyHandler handler
= handlers
[server
.master
->serverState
])
802 (this->*handler
)(reply
, data
);
804 writeForwardedReply(reply
);
805 } catch (const std::exception
&e
) {
807 throw TexcHere(e
.what());
812 Ftp::Server::handleFeatReply(const HttpReply
*reply
, StoreIOBuffer
)
814 if (pipeline
.front()->http
->request
->error
) {
815 writeCustomReply(502, "Server does not support FEAT", reply
);
820 HttpReply::Pointer featReply
= Ftp::HttpReplyWrapper(211, "End", Http::scNoContent
, 0);
821 HttpHeader
const &serverReplyHeader
= reply
->header
;
823 HttpHeaderPos pos
= HttpHeaderInitPos
;
824 bool hasEPRT
= false;
825 bool hasEPSV
= false;
826 int prependSpaces
= 1;
828 featReply
->header
.putStr(Http::HdrType::FTP_PRE
, "\"211-Features:\"");
829 const int scode
= serverReplyHeader
.getInt(Http::HdrType::FTP_STATUS
);
831 while (const HttpHeaderEntry
*e
= serverReplyHeader
.getEntry(&pos
)) {
832 if (e
->id
== Http::HdrType::FTP_PRE
) {
833 // assume RFC 2389 FEAT response format, quoted by Squid:
834 // <"> SP NAME [SP PARAMS] <">
835 // but accommodate MS servers sending four SPs before NAME
837 // command name ends with (SP parameter) or quote
838 static const CharacterSet
AfterFeatNameChars("AfterFeatName", " \"");
839 static const CharacterSet FeatNameChars
= AfterFeatNameChars
.complement("FeatName");
841 Parser::Tokenizer
tok(SBuf(e
->value
.termedBuf()));
842 if (!tok
.skip('"') || !tok
.skip(' '))
845 // optional spaces; remember their number to accommodate MS servers
846 prependSpaces
= 1 + tok
.skipAll(CharacterSet::SP
);
849 if (!tok
.prefix(cmd
, FeatNameChars
))
853 if (Ftp::SupportedCommand(cmd
)) {
854 featReply
->header
.addEntry(e
->clone());
857 if (cmd
== cmdEprt())
859 else if (cmd
== cmdEpsv())
863 } // else we got a FEAT error and will only report Squid-supported features
867 snprintf(buf
, sizeof(buf
), "\"%*s\"", prependSpaces
+ 4, "EPRT");
868 featReply
->header
.putStr(Http::HdrType::FTP_PRE
, buf
);
871 snprintf(buf
, sizeof(buf
), "\"%*s\"", prependSpaces
+ 4, "EPSV");
872 featReply
->header
.putStr(Http::HdrType::FTP_PRE
, buf
);
875 featReply
->header
.refreshMask();
877 writeForwardedReply(featReply
.getRaw());
881 Ftp::Server::handlePasvReply(const HttpReply
*reply
, StoreIOBuffer
)
883 const Http::StreamPointer
context(pipeline
.front());
884 assert(context
!= nullptr);
886 if (context
->http
->request
->error
) {
887 writeCustomReply(502, "Server does not support PASV", reply
);
891 const unsigned short localPort
= listenForDataConnection();
895 char addr
[MAX_IPSTRLEN
];
896 // remote server in interception setups and local address otherwise
897 const Ip::Address
&server
= transparent() ?
898 clientConnection
->local
: dataListenConn
->local
;
899 server
.toStr(addr
, MAX_IPSTRLEN
, AF_INET
);
900 addr
[MAX_IPSTRLEN
- 1] = '\0';
901 for (char *c
= addr
; *c
!= '\0'; ++c
) {
906 // In interception setups, we combine remote server address with a
907 // local port number and hope that traffic will be redirected to us.
908 // Do not use "227 =a,b,c,d,p1,p2" format or omit parens: some nf_ct_ftp
909 // versions block responses that use those alternative syntax rules!
912 mb
.appendf("227 Entering Passive Mode (%s,%i,%i).\r\n",
914 static_cast<int>(localPort
/ 256),
915 static_cast<int>(localPort
% 256));
916 debugs(9, 3, Raw("writing", mb
.buf
, mb
.size
));
921 Ftp::Server::handlePortReply(const HttpReply
*reply
, StoreIOBuffer
)
923 if (pipeline
.front()->http
->request
->error
) {
924 writeCustomReply(502, "Server does not support PASV (converted from PORT)", reply
);
928 writeCustomReply(200, "PORT successfully converted to PASV.");
934 Ftp::Server::handleErrorReply(const HttpReply
*reply
, StoreIOBuffer
)
936 if (!pinning
.pinned
) // we failed to connect to server
938 // 421: we will close due to fssError
939 writeErrorReply(reply
, 421);
943 Ftp::Server::handleDataReply(const HttpReply
*reply
, StoreIOBuffer data
)
945 if (reply
!= nullptr && reply
->sline
.status() != Http::scOkay
) {
946 writeForwardedReply(reply
);
947 if (Comm::IsConnOpen(dataConn
)) {
948 debugs(33, 3, "closing " << dataConn
<< " on KO reply");
949 closeDataConnection();
955 // We got STREAM_COMPLETE (or error) and closed the client data conn.
956 debugs(33, 3, "ignoring FTP srv data response after clt data closure");
960 if (!checkDataConnPost()) {
961 writeCustomReply(425, "Data connection is not established.");
962 closeDataConnection();
966 debugs(33, 7, data
.length
);
968 if (data
.length
<= 0) {
969 replyDataWritingCheckpoint(); // skip the actual write call
974 mb
.init(data
.length
+ 1, data
.length
+ 1);
975 mb
.append(data
.data
, data
.length
);
977 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
978 AsyncCall::Pointer call
= JobCallback(33, 5, Dialer
, this, Ftp::Server::wroteReplyData
);
979 Comm::Write(dataConn
, &mb
, call
);
981 pipeline
.front()->noteSentBodyBytes(data
.length
);
984 /// called when we are done writing a chunk of the response data
986 Ftp::Server::wroteReplyData(const CommIoCbParams
&io
)
988 if (io
.flag
== Comm::ERR_CLOSING
)
991 if (io
.flag
!= Comm::OK
) {
992 debugs(33, 3, "FTP reply data writing failed: " << xstrerr(io
.xerrno
));
993 userDataCompletionCheckpoint(426);
997 assert(pipeline
.front()->http
);
998 pipeline
.front()->http
->out
.size
+= io
.size
;
999 replyDataWritingCheckpoint();
1002 /// ClientStream checks after (actual or skipped) reply data writing
1004 Ftp::Server::replyDataWritingCheckpoint()
1006 switch (pipeline
.front()->socketState()) {
1008 debugs(33, 3, "Keep going");
1009 pipeline
.front()->pullData();
1011 case STREAM_COMPLETE
:
1012 debugs(33, 3, "FTP reply data transfer successfully complete");
1013 userDataCompletionCheckpoint(226);
1015 case STREAM_UNPLANNED_COMPLETE
:
1016 debugs(33, 3, "FTP reply data transfer failed: STREAM_UNPLANNED_COMPLETE");
1017 userDataCompletionCheckpoint(451);
1020 userDataCompletionCheckpoint(451);
1021 debugs(33, 3, "FTP reply data transfer failed: STREAM_FAILED");
1024 fatal("unreachable code");
1029 Ftp::Server::handleUploadReply(const HttpReply
*reply
, StoreIOBuffer
)
1031 writeForwardedReply(reply
);
1032 // note that the client data connection may already be closed by now
1036 Ftp::Server::writeForwardedReply(const HttpReply
*reply
)
1040 if (waitingForOrigin
) {
1041 Must(delayedReply
== nullptr);
1042 delayedReply
= reply
;
1046 const HttpHeader
&header
= reply
->header
;
1047 // adaptation and forwarding errors lack Http::HdrType::FTP_STATUS
1048 if (!header
.has(Http::HdrType::FTP_STATUS
)) {
1049 writeForwardedForeign(reply
); // will get to Ftp::Server::wroteReply
1053 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
1054 AsyncCall::Pointer call
= JobCallback(33, 5, Dialer
, this, Ftp::Server::wroteReply
);
1055 writeForwardedReplyAndCall(reply
, call
);
1059 Ftp::Server::handleEprtReply(const HttpReply
*reply
, StoreIOBuffer
)
1061 if (pipeline
.front()->http
->request
->error
) {
1062 writeCustomReply(502, "Server does not support PASV (converted from EPRT)", reply
);
1066 writeCustomReply(200, "EPRT successfully converted to PASV.");
1068 // and wait for RETR
1072 Ftp::Server::handleEpsvReply(const HttpReply
*reply
, StoreIOBuffer
)
1074 if (pipeline
.front()->http
->request
->error
) {
1075 writeCustomReply(502, "Cannot connect to server", reply
);
1079 const unsigned short localPort
= listenForDataConnection();
1083 // In interception setups, we use a local port number and hope that data
1084 // traffic will be redirected to us.
1087 mb
.appendf("229 Entering Extended Passive Mode (|||%u|)\r\n", localPort
);
1089 debugs(9, 3, Raw("writing", mb
.buf
, mb
.size
));
1093 /// writes FTP error response with given status and reply-derived error details
1095 Ftp::Server::writeErrorReply(const HttpReply
*reply
, const int scode
)
1097 const HttpRequest
*request
= pipeline
.front()->http
->request
;
1104 mb
.appendf("%i-%s\r\n", scode
, errorPageName(request
->error
.category
));
1106 if (const auto &detail
= request
->error
.detail
) {
1107 mb
.appendf("%i-Error-Detail-Brief: " SQUIDSBUFPH
"\r\n", scode
, SQUIDSBUFPRINT(detail
->brief()));
1108 mb
.appendf("%i-Error-Detail-Verbose: " SQUIDSBUFPH
"\r\n", scode
, SQUIDSBUFPRINT(detail
->verbose(request
)));
1112 // XXX: Remove hard coded names. Use an error page template instead.
1113 const Adaptation::History::Pointer ah
= request
->adaptHistory();
1114 if (ah
!= nullptr) { // XXX: add adapt::<all_h but use lastMeta here
1115 const String info
= ah
->allMeta
.getByName("X-Response-Info");
1116 const String desc
= ah
->allMeta
.getByName("X-Response-Desc");
1118 mb
.appendf("%i-Information: %s\r\n", scode
, info
.termedBuf());
1120 mb
.appendf("%i-Description: %s\r\n", scode
, desc
.termedBuf());
1124 const char *reason
= "Lost Error";
1126 reason
= reply
->header
.has(Http::HdrType::FTP_REASON
) ?
1127 reply
->header
.getStr(Http::HdrType::FTP_REASON
):
1128 reply
->sline
.reason();
1131 mb
.appendf("%i %s\r\n", scode
, reason
); // error terminating line
1133 // TODO: errorpage.cc should detect FTP client and use
1134 // configurable FTP-friendly error templates which we should
1135 // write to the client "as is" instead of hiding most of the info
1140 /// writes FTP response based on HTTP reply that is not an FTP-response wrapper
1141 /// for example, internally-generated Squid "errorpages" end up here (for now)
1143 Ftp::Server::writeForwardedForeign(const HttpReply
*reply
)
1145 changeState(fssConnected
, "foreign reply");
1146 closeDataConnection();
1147 // 451: We intend to keep the control connection open.
1148 writeErrorReply(reply
, 451);
1152 Ftp::Server::writeControlMsgAndCall(HttpReply
*reply
, AsyncCall::Pointer
&call
)
1154 // the caller guarantees that we are dealing with the current context only
1155 // the caller should also make sure reply->header.has(Http::HdrType::FTP_STATUS)
1156 writeForwardedReplyAndCall(reply
, call
);
1161 Ftp::Server::writeForwardedReplyAndCall(const HttpReply
*reply
, AsyncCall::Pointer
&call
)
1163 assert(reply
!= nullptr);
1164 const HttpHeader
&header
= reply
->header
;
1166 // without status, the caller must use the writeForwardedForeign() path
1167 Must(header
.has(Http::HdrType::FTP_STATUS
));
1168 Must(header
.has(Http::HdrType::FTP_REASON
));
1169 const int scode
= header
.getInt(Http::HdrType::FTP_STATUS
);
1170 debugs(33, 7, "scode: " << scode
);
1172 // Status 125 or 150 implies upload or data request, but we still check
1173 // the state in case the server is buggy.
1174 if ((scode
== 125 || scode
== 150) &&
1175 (master
->serverState
== fssHandleUploadRequest
||
1176 master
->serverState
== fssHandleDataRequest
)) {
1177 if (checkDataConnPost()) {
1178 // If the data connection is ready, start reading data (here)
1179 // and forward the response to client (further below).
1180 debugs(33, 7, "data connection established, start data transfer");
1181 if (master
->serverState
== fssHandleUploadRequest
)
1182 maybeReadUploadData();
1184 // If we are waiting to accept the data connection, keep waiting.
1185 if (Comm::IsConnOpen(dataListenConn
)) {
1186 debugs(33, 7, "wait for the client to establish a data connection");
1187 onDataAcceptCall
= call
;
1188 // TODO: Add connect timeout for passive connections listener?
1189 // TODO: Remember server response so that we can forward it?
1191 // Either the connection was establised and closed after the
1192 // data was transferred OR we failed to establish an active
1193 // data connection and already sent the error to the client.
1194 // In either case, there is nothing more to do.
1195 debugs(33, 7, "done with data OR active connection failed");
1203 Ftp::PrintReply(mb
, reply
);
1205 debugs(9, 2, "FTP Client " << clientConnection
);
1206 debugs(9, 2, "FTP Client REPLY:\n---------\n" << mb
.buf
<<
1209 Comm::Write(clientConnection
, &mb
, call
);
1213 Ftp::PrintReply(MemBuf
&mb
, const HttpReply
*reply
, const char *const)
1215 const HttpHeader
&header
= reply
->header
;
1217 HttpHeaderPos pos
= HttpHeaderInitPos
;
1218 while (const HttpHeaderEntry
*e
= header
.getEntry(&pos
)) {
1219 if (e
->id
== Http::HdrType::FTP_PRE
) {
1221 if (httpHeaderParseQuotedString(e
->value
.rawBuf(), e
->value
.size(), &raw
))
1222 mb
.appendf("%s\r\n", raw
.termedBuf());
1226 if (header
.has(Http::HdrType::FTP_STATUS
)) {
1227 const char *reason
= header
.getStr(Http::HdrType::FTP_REASON
);
1228 mb
.appendf("%i %s\r\n", header
.getInt(Http::HdrType::FTP_STATUS
),
1229 (reason
? reason
: nullptr));
1234 Ftp::Server::wroteEarlyReply(const CommIoCbParams
&io
)
1236 if (io
.flag
== Comm::ERR_CLOSING
)
1239 if (io
.flag
!= Comm::OK
) {
1240 debugs(33, 3, "FTP reply writing failed: " << xstrerr(io
.xerrno
));
1245 Http::StreamPointer context
= pipeline
.front();
1246 if (context
!= nullptr && context
->http
) {
1247 context
->http
->out
.size
+= io
.size
;
1248 context
->http
->out
.headers_sz
+= io
.size
;
1251 flags
.readMore
= true;
1256 Ftp::Server::wroteReply(const CommIoCbParams
&io
)
1258 if (io
.flag
== Comm::ERR_CLOSING
)
1261 if (io
.flag
!= Comm::OK
) {
1262 debugs(33, 3, "FTP reply writing failed: " << xstrerr(io
.xerrno
));
1267 Http::StreamPointer context
= pipeline
.front();
1268 assert(context
->http
);
1269 context
->http
->out
.size
+= io
.size
;
1270 context
->http
->out
.headers_sz
+= io
.size
;
1272 if (master
->serverState
== fssError
) {
1273 debugs(33, 5, "closing on FTP server error");
1278 const clientStream_status_t socketState
= context
->socketState();
1279 debugs(33, 5, "FTP client stream state " << socketState
);
1280 switch (socketState
) {
1281 case STREAM_UNPLANNED_COMPLETE
:
1287 case STREAM_COMPLETE
:
1288 flags
.readMore
= true;
1289 changeState(fssConnected
, "Ftp::Server::wroteReply");
1291 finishDechunkingRequest(false);
1292 context
->finished();
1299 Ftp::Server::handleRequest(HttpRequest
*request
)
1301 debugs(33, 9, request
);
1304 HttpHeader
&header
= request
->header
;
1305 Must(header
.has(Http::HdrType::FTP_COMMAND
));
1306 String
&cmd
= header
.findEntry(Http::HdrType::FTP_COMMAND
)->value
;
1307 Must(header
.has(Http::HdrType::FTP_ARGUMENTS
));
1308 String
¶ms
= header
.findEntry(Http::HdrType::FTP_ARGUMENTS
)->value
;
1310 if (Debug::Enabled(9, 2)) {
1315 debugs(9, 2, "FTP Client " << clientConnection
);
1316 debugs(9, 2, "FTP Client REQUEST:\n---------\n" << mb
.buf
<<
1320 // TODO: When HttpHeader uses SBuf, change keys to SBuf
1321 typedef std::map
<const std::string
, RequestHandler
> RequestHandlers
;
1322 static RequestHandlers handlers
;
1323 if (!handlers
.size()) {
1324 handlers
["LIST"] = &Ftp::Server::handleDataRequest
;
1325 handlers
["NLST"] = &Ftp::Server::handleDataRequest
;
1326 handlers
["MLSD"] = &Ftp::Server::handleDataRequest
;
1327 handlers
["FEAT"] = &Ftp::Server::handleFeatRequest
;
1328 handlers
["PASV"] = &Ftp::Server::handlePasvRequest
;
1329 handlers
["PORT"] = &Ftp::Server::handlePortRequest
;
1330 handlers
["RETR"] = &Ftp::Server::handleDataRequest
;
1331 handlers
["EPRT"] = &Ftp::Server::handleEprtRequest
;
1332 handlers
["EPSV"] = &Ftp::Server::handleEpsvRequest
;
1333 handlers
["CWD"] = &Ftp::Server::handleCwdRequest
;
1334 handlers
["PASS"] = &Ftp::Server::handlePassRequest
;
1335 handlers
["CDUP"] = &Ftp::Server::handleCdupRequest
;
1338 RequestHandler handler
= nullptr;
1339 if (request
->method
== Http::METHOD_PUT
)
1340 handler
= &Ftp::Server::handleUploadRequest
;
1342 const RequestHandlers::const_iterator hi
= handlers
.find(cmd
.termedBuf());
1343 if (hi
!= handlers
.end())
1344 handler
= hi
->second
;
1348 debugs(9, 7, "forwarding " << cmd
<< " as is, no post-processing");
1352 return (this->*handler
)(cmd
, params
);
1355 /// Called to parse USER command, which is required to create an HTTP request
1356 /// wrapper. W/o request, the errors are handled by returning earlyError().
1358 Ftp::Server::handleUserRequest(const SBuf
&, SBuf
¶ms
)
1360 if (params
.isEmpty())
1361 return earlyError(EarlyErrorKind::MissingUsername
);
1363 // find the [end of] user name
1364 const SBuf::size_type eou
= params
.rfind('@');
1365 if (eou
== SBuf::npos
|| eou
+ 1 >= params
.length())
1366 return earlyError(EarlyErrorKind::MissingHost
);
1368 // Determine the intended destination.
1369 host
= params
.substr(eou
+ 1, params
.length());
1370 // If we can parse it as raw IPv6 address, then surround with "[]".
1371 // Otherwise (domain, IPv4, [bracketed] IPv6, garbage, etc), use as is.
1372 if (host
.find(':') != SBuf::npos
) {
1373 const Ip::Address
ipa(host
.c_str());
1374 if (!ipa
.isAnyAddr()) {
1375 char ipBuf
[MAX_IPSTRLEN
];
1376 ipa
.toHostStr(ipBuf
, MAX_IPSTRLEN
);
1381 // const SBuf login = params.substr(0, eou);
1382 params
.chop(0, eou
); // leave just the login part for the peer
1385 if (master
->clientReadGreeting
)
1388 master
->workingDir
.clear();
1391 if (!master
->clientReadGreeting
) {
1392 debugs(9, 3, "set URI to " << uri
);
1393 } else if (oldUri
.caseCmp(uri
) == 0) {
1394 debugs(9, 5, "kept URI as " << oldUri
);
1396 debugs(9, 3, "reset URI from " << oldUri
<< " to " << uri
);
1397 closeDataConnection();
1398 unpinConnection(true); // close control connection to peer
1399 resetLogin("URI reset");
1402 return nullptr; // no early errors
1406 Ftp::Server::handleFeatRequest(String
&, String
&)
1408 changeState(fssHandleFeat
, "handleFeatRequest");
1413 Ftp::Server::handlePasvRequest(String
&, String
¶ms
)
1416 setReply(500, "Bad PASV command");
1420 if (params
.size() > 0) {
1421 setReply(501, "Unexpected parameter");
1425 changeState(fssHandlePasv
, "handlePasvRequest");
1426 // no need to fake PASV request via setDataCommand() in true PASV case
1430 /// [Re]initializes dataConn for active data transfers. Does not connect.
1432 Ftp::Server::createDataConnection(Ip::Address cltAddr
)
1434 assert(clientConnection
!= nullptr);
1435 assert(!clientConnection
->remote
.isAnyAddr());
1437 if (cltAddr
!= clientConnection
->remote
) {
1438 debugs(33, 2, "rogue PORT " << cltAddr
<< " request? ctrl: " << clientConnection
->remote
);
1439 // Closing the control connection would not help with attacks because
1440 // the client is evidently able to connect to us. Besides, closing
1441 // makes retrials easier for the client and more damaging to us.
1442 setReply(501, "Prohibited parameter value");
1446 closeDataConnection();
1448 Comm::ConnectionPointer conn
= new Comm::Connection();
1449 conn
->flags
|= COMM_DOBIND
;
1451 if (clientConnection
->flags
& COMM_INTERCEPTION
) {
1452 // In the case of NAT interception conn->local value is not set
1453 // because the TCP stack will automatically pick correct source
1454 // address for the data connection. We must only ensure that IP
1455 // version matches client's address.
1456 conn
->local
.setAnyAddr();
1458 if (cltAddr
.isIPv4())
1459 conn
->local
.setIPv4();
1461 conn
->remote
= cltAddr
;
1463 // In the case of explicit-proxy the local IP of the control connection
1464 // is the Squid IP the client is knowingly talking to.
1466 // In the case of TPROXY the IP address of the control connection is
1467 // server IP the client is connecting to, it can be spoofed by Squid.
1469 // In both cases some clients may refuse to accept data connections if
1470 // these control connectin local-IP's are not used.
1471 conn
->setAddrs(clientConnection
->local
, cltAddr
);
1473 // Using non-local addresses in TPROXY mode requires appropriate socket option.
1474 if (clientConnection
->flags
& COMM_TRANSPARENT
)
1475 conn
->flags
|= COMM_TRANSPARENT
;
1478 // RFC 959 requires active FTP connections to originate from port 20
1479 // but that would preclude us from supporting concurrent transfers! (XXX?)
1480 conn
->local
.port(0);
1482 debugs(9, 3, "will actively connect from " << conn
->local
<< " to " <<
1486 uploadAvailSize
= 0;
1491 Ftp::Server::handlePortRequest(String
&, String
¶ms
)
1493 // TODO: Should PORT errors trigger closeDataConnection() cleanup?
1496 setReply(500, "Rejecting PORT after EPSV ALL");
1500 if (!params
.size()) {
1501 setReply(501, "Missing parameter");
1505 Ip::Address cltAddr
;
1506 if (!Ftp::ParseIpPort(params
.termedBuf(), nullptr, cltAddr
)) {
1507 setReply(501, "Invalid parameter");
1511 if (!createDataConnection(cltAddr
))
1514 changeState(fssHandlePort
, "handlePortRequest");
1516 return true; // forward our fake PASV request
1520 Ftp::Server::handleDataRequest(String
&, String
&)
1522 if (!checkDataConnPre())
1525 master
->userDataDone
= 0;
1526 originDataDownloadAbortedOnError
= false;
1528 changeState(fssHandleDataRequest
, "handleDataRequest");
1534 Ftp::Server::handleUploadRequest(String
&, String
&)
1536 if (!checkDataConnPre())
1539 if (Config
.accessList
.forceRequestBodyContinuation
) {
1540 ClientHttpRequest
*http
= pipeline
.front()->http
;
1541 HttpRequest
*request
= http
->request
;
1542 ACLFilledChecklist
bodyContinuationCheck(Config
.accessList
.forceRequestBodyContinuation
, request
, nullptr);
1543 bodyContinuationCheck
.al
= http
->al
;
1544 bodyContinuationCheck
.syncAle(request
, http
->log_uri
);
1545 if (bodyContinuationCheck
.fastCheck().allowed()) {
1546 request
->forcedBodyContinuation
= true;
1547 if (checkDataConnPost()) {
1548 // Write control Msg
1549 writeEarlyReply(150, "Data connection opened");
1550 maybeReadUploadData();
1552 // wait for acceptDataConnection but tell it to call wroteEarlyReply
1553 // after writing "150 Data connection opened"
1554 typedef CommCbMemFunT
<Server
, CommIoCbParams
> Dialer
;
1555 AsyncCall::Pointer call
= JobCallback(33, 5, Dialer
, this, Ftp::Server::wroteEarlyReply
);
1556 onDataAcceptCall
= call
;
1561 changeState(fssHandleUploadRequest
, "handleDataRequest");
1567 Ftp::Server::handleEprtRequest(String
&, String
¶ms
)
1569 debugs(9, 3, "Process an EPRT " << params
);
1572 setReply(500, "Rejecting EPRT after EPSV ALL");
1576 if (!params
.size()) {
1577 setReply(501, "Missing parameter");
1581 Ip::Address cltAddr
;
1582 if (!Ftp::ParseProtoIpPort(params
.termedBuf(), cltAddr
)) {
1583 setReply(501, "Invalid parameter");
1587 if (!createDataConnection(cltAddr
))
1590 changeState(fssHandleEprt
, "handleEprtRequest");
1592 return true; // forward our fake PASV request
1596 Ftp::Server::handleEpsvRequest(String
&, String
¶ms
)
1598 debugs(9, 3, "Process an EPSV command with params: " << params
);
1599 if (params
.size() <= 0) {
1600 // treat parameterless EPSV as "use the protocol of the ctrl conn"
1601 } else if (params
.caseCmp("ALL") == 0) {
1602 setReply(200, "EPSV ALL ok");
1605 } else if (params
.cmp("2") == 0) {
1606 if (!Ip::EnableIpv6
) {
1607 setReply(522, "Network protocol not supported, use (1)");
1610 } else if (params
.cmp("1") != 0) {
1611 setReply(501, "Unsupported EPSV parameter");
1615 changeState(fssHandleEpsv
, "handleEpsvRequest");
1617 return true; // forward our fake PASV request
1621 Ftp::Server::handleCwdRequest(String
&, String
&)
1623 changeState(fssHandleCwd
, "handleCwdRequest");
1628 Ftp::Server::handlePassRequest(String
&, String
&)
1630 changeState(fssHandlePass
, "handlePassRequest");
1635 Ftp::Server::handleCdupRequest(String
&, String
&)
1637 changeState(fssHandleCdup
, "handleCdupRequest");
1641 // Convert user PORT, EPRT, PASV, or EPSV data command to Squid PASV command.
1642 // Squid FTP client decides what data command to use with peers.
1644 Ftp::Server::setDataCommand()
1646 ClientHttpRequest
*const http
= pipeline
.front()->http
;
1647 assert(http
!= nullptr);
1648 HttpRequest
*const request
= http
->request
;
1649 assert(request
!= nullptr);
1650 HttpHeader
&header
= request
->header
;
1651 static const SBuf
pasvValue("PASV");
1652 header
.updateOrAddStr(Http::HdrType::FTP_COMMAND
, pasvValue
);
1653 static const SBuf
emptyValue("");
1654 header
.updateOrAddStr(Http::HdrType::FTP_ARGUMENTS
, emptyValue
);
1655 debugs(9, 5, "client data command converted to fake PASV");
1658 /// check that client data connection is ready for future I/O or at least
1659 /// has a chance of becoming ready soon.
1661 Ftp::Server::checkDataConnPre()
1663 if (Comm::IsConnOpen(dataConn
))
1666 if (Comm::IsConnOpen(dataListenConn
)) {
1667 // We are still waiting for a client to connect to us after PASV.
1668 // Perhaps client's data conn handshake has not reached us yet.
1669 // After we talk to the server, checkDataConnPost() will recheck.
1670 debugs(33, 3, "expecting clt data conn " << dataListenConn
);
1674 if (!dataConn
|| dataConn
->remote
.isAnyAddr()) {
1675 debugs(33, 5, "missing " << dataConn
);
1676 // TODO: use client address and default port instead.
1677 setReply(425, "Use PORT or PASV first");
1681 // active transfer: open a data connection from Squid to client
1682 typedef CommCbMemFunT
<Server
, CommConnectCbParams
> Dialer
;
1683 AsyncCall::Pointer callback
= JobCallback(17, 3, Dialer
, this, Ftp::Server::connectedForData
);
1684 const auto cs
= new Comm::ConnOpener(dataConn
->cloneProfile(), callback
,
1685 Config
.Timeout
.connect
);
1686 dataConnWait
.start(cs
, callback
);
1690 /// Check that client data connection is ready for immediate I/O.
1692 Ftp::Server::checkDataConnPost() const
1694 if (!Comm::IsConnOpen(dataConn
)) {
1695 debugs(33, 3, "missing client data conn: " << dataConn
);
1701 /// Done establishing a data connection to the user.
1703 Ftp::Server::connectedForData(const CommConnectCbParams
¶ms
)
1705 dataConnWait
.finish();
1707 if (params
.flag
!= Comm::OK
) {
1708 setReply(425, "Cannot open data connection.");
1709 Http::StreamPointer context
= pipeline
.front();
1710 Must(context
->http
);
1711 Must(context
->http
->storeEntry() != nullptr);
1712 // TODO: call closeDataConnection() to reset data conn processing?
1714 // Finalize the details and start owning the supplied connection.
1715 assert(params
.conn
);
1717 assert(!dataConn
->isOpen());
1718 dataConn
= params
.conn
;
1719 // XXX: Missing comm_add_close_handler() to track external closures.
1721 Must(Comm::IsConnOpen(params
.conn
));
1722 fd_note(params
.conn
->fd
, "active client ftp data");
1729 Ftp::Server::setReply(const int code
, const char *msg
)
1731 Http::StreamPointer context
= pipeline
.front();
1732 ClientHttpRequest
*const http
= context
->http
;
1733 assert(http
!= nullptr);
1734 assert(http
->storeEntry() == nullptr);
1736 HttpReply
*const reply
= Ftp::HttpReplyWrapper(code
, msg
, Http::scNoContent
, 0);
1738 clientStreamNode
*const node
= context
->getClientReplyContext();
1739 clientReplyContext
*const repContext
=
1740 dynamic_cast<clientReplyContext
*>(node
->data
.getRaw());
1741 assert(repContext
!= nullptr);
1743 RequestFlags reqFlags
;
1744 reqFlags
.disableCacheUse("FTP response wrapper");
1745 repContext
->createStoreEntry(http
->request
->method
, reqFlags
);
1746 http
->storeEntry()->replaceHttpReply(reply
);
1750 Ftp::Server::callException(const std::exception
&e
)
1752 debugs(33, 2, "FTP::Server job caught: " << e
.what());
1753 closeDataConnection();
1754 unpinConnection(true);
1755 if (Comm::IsConnOpen(clientConnection
))
1756 clientConnection
->close();
1757 AsyncJob::callException(e
);
1761 Ftp::Server::startWaitingForOrigin()
1763 if (!isOpen()) // if we are closing, nothing to do
1766 debugs(33, 5, "waiting for Ftp::Client data transfer to end");
1767 waitingForOrigin
= true;
1771 Ftp::Server::stopWaitingForOrigin(int originStatus
)
1773 Must(waitingForOrigin
);
1774 waitingForOrigin
= false;
1776 if (!isOpen()) // if we are closing, nothing to do
1779 // if we have already decided how to respond, respond now
1781 HttpReply::Pointer reply
= delayedReply
;
1782 delayedReply
= nullptr;
1783 writeForwardedReply(reply
.getRaw());
1784 return; // do not completeDataDownload() after an earlier response
1787 if (master
->serverState
!= fssHandleDataRequest
)
1790 // completeDataDownload() could be waitingForOrigin in fssHandleDataRequest
1791 // Depending on which side has finished downloading first, either trust
1792 // master->userDataDone status or set originDataDownloadAbortedOnError:
1793 if (master
->userDataDone
) {
1794 // We finished downloading before Ftp::Client. Most likely, the
1795 // adaptation shortened the origin response or we hit an error.
1796 // Our status (stored in master->userDataDone) is more informative.
1797 // Use master->userDataDone; avoid originDataDownloadAbortedOnError.
1798 completeDataDownload();
1800 debugs(33, 5, "too early to write the response");
1801 // Ftp::Client naturally finished downloading before us. Set
1802 // originDataDownloadAbortedOnError to overwrite future
1803 // master->userDataDone and relay Ftp::Client error, if there was
1804 // any, to the user.
1805 originDataDownloadAbortedOnError
= (originStatus
>= 400);
1809 void Ftp::Server::userDataCompletionCheckpoint(int finalStatusCode
)
1811 Must(!master
->userDataDone
);
1812 master
->userDataDone
= finalStatusCode
;
1815 finishDechunkingRequest(false);
1817 if (waitingForOrigin
) {
1818 // The completeDataDownload() is not called here unconditionally
1819 // because we want to signal the FTP user that we are not fully
1820 // done processing its data stream, even though all data bytes
1821 // have been sent or received already.
1822 debugs(33, 5, "Transferring from FTP server is not complete");
1826 // Adjust our reply if the server aborted with an error before we are done.
1827 if (master
->userDataDone
== 226 && originDataDownloadAbortedOnError
) {
1828 debugs(33, 5, "Transferring from FTP server terminated with an error, adjust status code");
1829 master
->userDataDone
= 451;
1831 completeDataDownload();
1834 void Ftp::Server::completeDataDownload()
1836 writeCustomReply(master
->userDataDone
, master
->userDataDone
== 226 ? "Transfer complete" : "Server error; transfer aborted");
1837 closeDataConnection();
1840 /// Whether Squid FTP Relay supports a named feature (e.g., a command).
1842 Ftp::SupportedCommand(const SBuf
&name
)
1844 static std::set
<SBuf
> BlockList
;
1845 if (BlockList
.empty()) {
1846 /* Add FTP commands that Squid cannot relay correctly. */
1848 // We probably do not support AUTH TLS.* and AUTH SSL,
1849 // but let's disclaim all AUTH support to KISS, for now.
1850 BlockList
.insert(cmdAuth());
1853 // we claim support for all commands that we do not know about
1854 return BlockList
.find(name
) == BlockList
.end();