Fix build issues after trunk rev.13534 merge

FTP server addition to trunk pulled in design changes to the HTTP parse
and processing. Adding an HTTP server component as well. This branch code
clashed and fails to build without a matching redesign.

Not yet run tested. Just building again.

diff --git a/src/Makefile.am b/src/Makefile.am
index 092cf88916ad89e5953c9139d97848f3a2064d8a..d89f27a2ea49f7bd4b8f221871499a5b6eba85df 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -617,6 +617,9 @@ squid_LDADD = \
        $(AUTH_LIBS) \
        $(DISK_LIBS) \
        acl/libapi.la \
+       clients/libclients.la \
+       servers/libservers.la \
+       ftp/libftp.la \
        http/libsquid-http.la \
        parser/libsquid-parser.la \
        base/libbase.la \
@@ -632,9 +635,6 @@ squid_LDADD = \
        icmp/libicmp.la icmp/libicmp-core.la \
        log/liblog.la \
        format/libformat.la \
-       clients/libclients.la \
-       servers/libservers.la \
-       ftp/libftp.la \
        $(XTRA_OBJS) \
        $(DISK_LINKOBJS) \
        $(REPL_OBJS) \
@@ -1603,14 +1603,13 @@ nodist_tests_testCacheManager_SOURCES = \
 tests_testCacheManager_LDADD = \
        clients/libclients.la \
        servers/libservers.la \
-       http/libsquid-http.la \
        ftp/libftp.la \
+       http/libsquid-http.la \
        parser/libsquid-parser.la \
        ident/libident.la \
        acl/libacls.la \
        acl/libstate.la \
        acl/libapi.la \
-       parser/libsquid-parser.la \
        base/libbase.la \
        libsquid.la \
        ip/libip.la \
@@ -2037,14 +2036,13 @@ nodist_tests_testEvent_SOURCES = \
 tests_testEvent_LDADD = \
        clients/libclients.la \
        servers/libservers.la \
-       http/libsquid-http.la \
        ftp/libftp.la \
+       http/libsquid-http.la \
        parser/libsquid-parser.la \
        ident/libident.la \
        acl/libacls.la \
        acl/libstate.la \
        acl/libapi.la \
-       parser/libsquid-parser.la \
        base/libbase.la \
        libsquid.la \
        ip/libip.la \
@@ -2287,14 +2285,13 @@ nodist_tests_testEventLoop_SOURCES = \
 tests_testEventLoop_LDADD = \
        clients/libclients.la \
        servers/libservers.la \
-       http/libsquid-http.la \
        ftp/libftp.la \
+       http/libsquid-http.la \
        parser/libsquid-parser.la \
        ident/libident.la \
        acl/libacls.la \
        acl/libstate.la \
        acl/libapi.la \
-       parser/libsquid-parser.la \
        base/libbase.la \
        libsquid.la \
        ip/libip.la \
@@ -2530,14 +2527,13 @@ nodist_tests_test_http_range_SOURCES = \
 tests_test_http_range_LDADD = \
        clients/libclients.la \
        servers/libservers.la \
-       http/libsquid-http.la \
        ftp/libftp.la \
+       http/libsquid-http.la \
        parser/libsquid-parser.la \
        ident/libident.la \
        acl/libacls.la \
        acl/libstate.la \
        acl/libapi.la \
-       parser/libsquid-parser.la \
        libsquid.la \
        ip/libip.la \
        fs/libfs.la \
@@ -2825,6 +2821,7 @@ tests_testHttpRequest_LDADD = \
        clients/libclients.la \
        servers/libservers.la \
        ftp/libftp.la \
+       http/libsquid-http.la \
        ident/libident.la \
        acl/libacls.la \
        acl/libstate.la \
@@ -2834,7 +2831,6 @@ tests_testHttpRequest_LDADD = \
        fs/libfs.la \
        $(SSL_LIBS) \
        ipc/libipc.la \
-       http/libsquid-http.la \
        parser/libsquid-parser.la \
        base/libbase.la \
        mgr/libmgr.la \
@@ -3673,7 +3669,6 @@ tests_testURL_LDADD = \
        eui/libeui.la \
        acl/libstate.la \
        acl/libapi.la \
-       parser/libsquid-parser.la \
        base/libbase.la \
        libsquid.la \
        ip/libip.la \

diff --git a/src/client_side.cc b/src/client_side.cc
index 1e60f46597ce8d3b8dd7e16c401d689f19981c93..6d91e8f5104bdf43d4b2a28fc98b5cc2dea474e3 100644 (file)
--- a/src/client_side.cc
+++ b/src/client_side.cc
@@ -2018,7 +2018,7 @@ setLogUri(ClientHttpRequest * http, char const *uri, bool cleanUrl)
 }
 
 static void
-prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::RequestParser &hp)
+prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, const Http1::RequestParserPointer &hp)
 {
     int vhost = conn->port->vhost;
     int vport = conn->port->vport;
@@ -2029,11 +2029,11 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
     /* BUG: Squid cannot deal with '*' URLs (RFC2616 5.1.2) */
 
     static const SBuf cache_object("cache_object://");
-    if (hp.requestUri().startsWith(cache_object))
+    if (hp->requestUri().startsWith(cache_object))
         return; /* already in good shape */
 
     // XXX: re-use proper URL parser for this
-    SBuf url = hp.requestUri(); // use full provided URI if we abort
+    SBuf url = hp->requestUri(); // use full provided URI if we abort
     do { // use a loop so we can break out of it
         ::Parser::Tokenizer tok(url);
         if (tok.remaining()[0] == '/')
@@ -2043,18 +2043,16 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
             return; /* already in good shape */
 
         // skip the URI scheme
-        static const CharacterSet uriScheme = CharacterSet::ALPHA + CharacterSet::DIGIT + CharacterSet(NULL,"+-.");
+        static const CharacterSet uriScheme = CharacterSet("URI-scheme","+-.") + CharacterSet::ALPHA + CharacterSet::DIGIT;
         static const SBuf uriSchemeEnd("://");
-        if (!tok.skip(uriScheme))
-            break;
-        if (!tok.skip(uriSchemeEnd))
+        if (!tok.skipAll(uriScheme) || !tok.skip(uriSchemeEnd))
             break;
 
         // skip the authority segment
         // RFC 3986 complex nested ABNF for "authority" boils down to this:
         static const CharacterSet authority = CharacterSet("authority","-._~%:@[]!$&'()*+,;=") +
              CharacterSet::HEXDIG + CharacterSet::ALPHA + CharacterSet::DIGIT;
-        if (!tok.skip(authority))
+        if (!tok.skipAll(authority))
             break;
 
         static const SBuf slashUri("/");
@@ -2073,7 +2071,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
 #if SHOULD_REJECT_UNKNOWN_URLS
     // reject URI which are not well-formed even after the processing above
     if (url[0] != '/') {
-        hp.request_parse_status = Http::scBadRequest;
+        hp->request_parse_status = Http::scBadRequest;
         return parseHttpRequestAbort(conn, "error:invalid-request");
     }
 #endif
@@ -2084,7 +2082,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
     const bool switchedToHttps = conn->switchedToHttps();
     const bool tryHostHeader = vhost || switchedToHttps;
     char *host = NULL;
-    if (tryHostHeader && (host = hp.getHeaderField("Host"))) {
+    if (tryHostHeader && (host = hp->getHeaderField("Host"))) {
         debugs(33, 5, "ACCEL VHOST REWRITE: vhost=" << host << " + vport=" << vport);
         char thost[256];
         if (vport > 0) {
@@ -2099,7 +2097,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
                 host = thost;
             }
         } // else nothing to alter port-wise.
-        const int url_sz = hp.requestUri().length() + 32 + Config.appendDomainLen + strlen(host);
+        const int url_sz = hp->requestUri().length() + 32 + Config.appendDomainLen + strlen(host);
         http->uri = (char *)xcalloc(url_sz, 1);
         const char *protocol = switchedToHttps ?
                                "https" : AnyP::UriScheme(conn->port->transport.protocol).c_str();
@@ -2107,7 +2105,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
         debugs(33, 5, "ACCEL VHOST REWRITE: " << http->uri);
     } else if (conn->port->defaultsite /* && !vhost */) {
         debugs(33, 5, "ACCEL DEFAULTSITE REWRITE: defaultsite=" << conn->port->defaultsite << " + vport=" << vport);
-        const int url_sz = hp.requestUri().length() + 32 + Config.appendDomainLen +
+        const int url_sz = hp->requestUri().length() + 32 + Config.appendDomainLen +
                      strlen(conn->port->defaultsite);
         http->uri = (char *)xcalloc(url_sz, 1);
         char vportStr[32];
@@ -2121,7 +2119,7 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
     } else if (vport > 0 /* && (!vhost || no Host:) */) {
         debugs(33, 5, "ACCEL VPORT REWRITE: *_port IP + vport=" << vport);
         /* Put the local socket IP address as the hostname, with whatever vport we found  */
-        const int url_sz = hp.requestUri().length() + 32 + Config.appendDomainLen;
+        const int url_sz = hp->requestUri().length() + 32 + Config.appendDomainLen;
         http->uri = (char *)xcalloc(url_sz, 1);
         http->getConn()->clientConnection->local.toHostStr(ipbuf,MAX_IPSTRLEN);
         snprintf(http->uri, url_sz, "%s://%s:%d" SQUIDSBUFPH,
@@ -2132,31 +2130,31 @@ prepareAcceleratedURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
 }
 
 static void
-prepareTransparentURL(ConnStateData * conn, ClientHttpRequest *http, Http1::RequestParser &hp)
+prepareTransparentURL(ConnStateData * conn, ClientHttpRequest *http, const Http1::RequestParserPointer &hp)
 {
     static char ipbuf[MAX_IPSTRLEN];
 
     // TODO Must() on URI !empty when the parser supports throw. For now avoid assert().
-    if (!hp.requestUri().isEmpty() && hp.requestUri()[0] != '/')
+    if (!hp->requestUri().isEmpty() && hp->requestUri()[0] != '/')
         return; /* already in good shape */
 
     /* BUG: Squid cannot deal with '*' URLs (RFC2616 5.1.2) */
 
-    if (const char *host = hp.getHeaderField("Host")) {
-        const int url_sz = hp.requestUri().length() + 32 + Config.appendDomainLen +
+    if (const char *host = hp->getHeaderField("Host")) {
+        const int url_sz = hp->requestUri().length() + 32 + Config.appendDomainLen +
                      strlen(host);
         http->uri = (char *)xcalloc(url_sz, 1);
         snprintf(http->uri, url_sz, "%s://%s" SQUIDSBUFPH,
-             AnyP::UriScheme(conn->port->transport.protocol).c_str(), host, SQUIDSBUFPRINT(hp.requestUri()));
+             AnyP::UriScheme(conn->port->transport.protocol).c_str(), host, SQUIDSBUFPRINT(hp->requestUri()));
         debugs(33, 5, "TRANSPARENT HOST REWRITE: " << http->uri);
     } else {
         /* Put the local socket IP address as the hostname.  */
-        const int url_sz = hp.requestUri().length() + 32 + Config.appendDomainLen;
+        const int url_sz = hp->requestUri().length() + 32 + Config.appendDomainLen;
         http->uri = (char *)xcalloc(url_sz, 1);
         http->getConn()->clientConnection->local.toHostStr(ipbuf,MAX_IPSTRLEN);
         snprintf(http->uri, url_sz, "%s://%s:%d" SQUIDSBUFPH,
                  AnyP::UriScheme(http->getConn()->port->transport.protocol).c_str(),
-                 ipbuf, http->getConn()->clientConnection->local.port(), SQUIDSBUFPRINT(hp.requestUri()));
+                 ipbuf, http->getConn()->clientConnection->local.port(), SQUIDSBUFPRINT(hp->requestUri()));
         debugs(33, 5, "TRANSPARENT REWRITE: " << http->uri);
     }
 }
@@ -2175,22 +2173,22 @@ prepareTransparentURL(ConnStateData * conn, ClientHttpRequest *http, Http1::Requ
  *          a ClientSocketContext structure on success or failure.
  */
 ClientSocketContext *
-parseHttpRequest(ConnStateData *csd, Http1::RequestParser &hp)
+parseHttpRequest(ConnStateData *csd, const Http1::RequestParserPointer &hp)
 {
     /* Attempt to parse the first line; this will define where the method, url, version and header begin */
     {
-        const bool parsedOk = hp.parse(csd->in.buf);
+        const bool parsedOk = hp->parse(csd->in.buf);
 
         // sync the buffers after parsing.
-        csd->in.buf = hp.remaining();
+        csd->in.buf = hp->remaining();
 
-        if (hp.needsMoreData()) {
+        if (hp->needsMoreData()) {
             debugs(33, 5, "Incomplete request, waiting for end of request line");
             return NULL;
         }
 
         if (!parsedOk) {
-            if (hp.request_parse_status == Http::scHeaderTooLarge)
+            if (hp->request_parse_status == Http::scHeaderTooLarge)
                 return parseHttpRequestAbort(csd, "error:request-too-large");
 
             return parseHttpRequestAbort(csd, "error:invalid-request");
@@ -2200,35 +2198,35 @@ parseHttpRequest(ConnStateData *csd, Http1::RequestParser &hp)
     /* We know the whole request is in parser now */
     debugs(11, 2, "HTTP Client " << csd->clientConnection);
     debugs(11, 2, "HTTP Client REQUEST:\n---------\n" <<
-           hp.method() << " " << hp.requestUri() << " " << hp.messageProtocol() << "\n" <<
-           hp.mimeHeader() <<
+           hp->method() << " " << hp->requestUri() << " " << hp->messageProtocol() << "\n" <<
+           hp->mimeHeader() <<
            "\n----------");
 
     /* deny CONNECT via accelerated ports */
-    if (hp.method() == Http::METHOD_CONNECT && csd->port != NULL && csd->port->flags.accelSurrogate) {
+    if (hp->method() == Http::METHOD_CONNECT && csd->port != NULL && csd->port->flags.accelSurrogate) {
         debugs(33, DBG_IMPORTANT, "WARNING: CONNECT method received on " << csd->port->transport.protocol << " Accelerator port " << csd->port->s.port());
-        debugs(33, DBG_IMPORTANT, "WARNING: for request: " << hp.method() << " " << hp.requestUri() << " " << hp.messageProtocol());
-        hp.request_parse_status = Http::scMethodNotAllowed;
+        debugs(33, DBG_IMPORTANT, "WARNING: for request: " << hp->method() << " " << hp->requestUri() << " " << hp->messageProtocol());
+        hp->request_parse_status = Http::scMethodNotAllowed;
         return parseHttpRequestAbort(csd, "error:method-not-allowed");
     }
 
-    if (hp.method() == Http::METHOD_NONE) {
-        debugs(33, DBG_IMPORTANT, "WARNING: Unsupported method: " << hp.method() << " " << hp.requestUri() << " " << hp.messageProtocol());
-        hp.request_parse_status = Http::scMethodNotAllowed;
+    if (hp->method() == Http::METHOD_NONE) {
+        debugs(33, DBG_IMPORTANT, "WARNING: Unsupported method: " << hp->method() << " " << hp->requestUri() << " " << hp->messageProtocol());
+        hp->request_parse_status = Http::scMethodNotAllowed;
         return parseHttpRequestAbort(csd, "error:unsupported-request-method");
     }
 
     // Process headers after request line
     debugs(33, 3, "complete request received. " <<
-           "prefix_sz = " << hp.messageHeaderSize() <<
-           ", request-line-size=" << hp.firstLineSize() <<
-           ", mime-header-size=" << hp.headerBlockSize() <<
-           ", mime header block:\n" << hp.mimeHeader() << "\n----------");
+           "prefix_sz = " << hp->messageHeaderSize() <<
+           ", request-line-size=" << hp->firstLineSize() <<
+           ", mime-header-size=" << hp->headerBlockSize() <<
+           ", mime header block:\n" << hp->mimeHeader() << "\n----------");
 
     /* Ok, all headers are received */
     ClientHttpRequest *http = new ClientHttpRequest(csd);
 
-    http->req_sz = hp.messageHeaderSize();
+    http->req_sz = hp->messageHeaderSize();
     ClientSocketContext *result = new ClientSocketContext(csd->clientConnection, http);
 
     StoreIOBuffer tempBuffer;
@@ -2244,7 +2242,7 @@ parseHttpRequest(ConnStateData *csd, Http1::RequestParser &hp)
     /* set url */
     // XXX: c_str() does re-allocate but here replaces explicit malloc/free.
     // when internalCheck() accepts SBuf removing this will be a net gain for performance.
-    const char *url = SBuf(hp.requestUri()).c_str();
+    const char *url = SBuf(hp->requestUri()).c_str();
 
     debugs(33,5, HERE << "repare absolute URL from " <<
            (csd->transparent()?"intercept":(csd->port->flags.accelSurrogate ? "accel":"")));
@@ -2279,7 +2277,7 @@ parseHttpRequest(ConnStateData *csd, Http1::RequestParser &hp)
     if (!http->uri) {
         /* No special rewrites have been applied above, use the
          * requested url. may be rewritten later, so make extra room */
-        int url_sz = hp.requestUri().length() + Config.appendDomainLen + 5;
+        int url_sz = hp->requestUri().length() + Config.appendDomainLen + 5;
         http->uri = (char *)xcalloc(url_sz, 1);
         strcpy(http->uri, url);
     }
@@ -2479,8 +2477,8 @@ bool ConnStateData::serveDelayedError(ClientSocketContext *context)
 }
 #endif // USE_OPENSSL
 
-static void
-clientProcessRequest(ConnStateData *conn, Http1::RequestParser &hp, ClientSocketContext *context)
+void
+clientProcessRequest(ConnStateData *conn, const Http1::RequestParserPointer &hp, ClientSocketContext *context)
 {
     ClientHttpRequest *http = context->http;
     HttpRequest::Pointer request;
@@ -2488,22 +2486,18 @@ clientProcessRequest(ConnStateData *conn, Http1::RequestParser &hp, ClientSocket
     bool mustReplyToOptions = false;
     bool unsupportedTe = false;
     bool expectBody = false;
-    const AnyP::ProtocolVersion &http_ver = hp.messageProtocol();
-    const HttpRequestMethod &method = hp.method();
 
     // temporary hack to avoid splitting this huge function with sensitive code
-    const bool isFtp = !hp;
+    const bool isFtp = (hp == NULL);
+    const HttpRequestMethod &method = !isFtp ? hp->method() : Http::METHOD_NONE; // XXX: or should this be GET ?
     if (isFtp) {
         // In FTP, case, we already have the request parsed and checked, so we
         // only need to go through the final body/conn setup to doCallouts().
         assert(http->request);
         request = http->request;
-        notedUseOfBuffer = true;
-        goto doFtpAndHttp;
-    }
+    } else {
 
     if (context->flags.parsed_ok == 0) {
-        assert(hp);
         clientStreamNode *node = context->getClientReplyContext();
         debugs(33, 2, "Invalid Request");
         conn->quitAfterError(NULL);
@@ -2511,21 +2505,21 @@ clientProcessRequest(ConnStateData *conn, Http1::RequestParser &hp, ClientSocket
         setLogUri(http, http->uri,  true);
         clientReplyContext *repContext = dynamic_cast<clientReplyContext *>(node->data.getRaw());
         assert (repContext);
-        switch (hp.request_parse_status) {
+        switch (hp->request_parse_status) {
         case Http::scHeaderTooLarge:
-            repContext->setReplyToError(ERR_TOO_BIG, Http::scBadRequest, method, http->uri,
+            repContext->setReplyToError(ERR_TOO_BIG, Http::scBadRequest, hp->method(), http->uri,
                                         conn->clientConnection->remote, NULL, conn->in.buf.c_str(), NULL);
             break;
         case Http::scMethodNotAllowed:
-            repContext->setReplyToError(ERR_UNSUP_REQ, Http::scMethodNotAllowed, method, http->uri,
+            repContext->setReplyToError(ERR_UNSUP_REQ, Http::scMethodNotAllowed, hp->method(), http->uri,
                                         conn->clientConnection->remote, NULL, conn->in.buf.c_str(), NULL);
             break;
         case Http::scHttpVersionNotSupported:
-            repContext->setReplyToError(ERR_UNSUP_HTTPVERSION, Http::scHttpVersionNotSupported, method, http->uri,
+            repContext->setReplyToError(ERR_UNSUP_HTTPVERSION, Http::scHttpVersionNotSupported, hp->method(), http->uri,
                                         conn->clientConnection->remote, NULL, conn->in.buf.c_str(), NULL);
             break;
         default:
-            repContext->setReplyToError(ERR_INVALID_REQ, hp.request_parse_status, method, http->uri,
+            repContext->setReplyToError(ERR_INVALID_REQ, hp->request_parse_status, hp->method(), http->uri,
                                         conn->clientConnection->remote, NULL, conn->in.buf.c_str(), NULL);
         }
         assert(context->http->out.offset == 0);
@@ -2533,7 +2527,7 @@ clientProcessRequest(ConnStateData *conn, Http1::RequestParser &hp, ClientSocket
         goto finish;
     }
 
-    if ((request = HttpRequest::CreateFromUrlAndMethod(http->uri, method)) == NULL) {
+    if ((request = HttpRequest::CreateFromUrlAndMethod(http->uri, hp->method())) == NULL) {
         clientStreamNode *node = context->getClientReplyContext();
         debugs(33, 5, "Invalid URL: " << http->uri);
         conn->quitAfterError(request.getRaw());
@@ -2541,28 +2535,29 @@ clientProcessRequest(ConnStateData *conn, Http1::RequestParser &hp, ClientSocket
         setLogUri(http, http->uri,  true);
         clientReplyContext *repContext = dynamic_cast<clientReplyContext *>(node->data.getRaw());
         assert (repContext);
-        repContext->setReplyToError(ERR_INVALID_URL, Http::scBadRequest, method, http->uri, conn->clientConnection->remote, NULL, NULL, NULL);
+        repContext->setReplyToError(ERR_INVALID_URL, Http::scBadRequest, hp->method(), http->uri, conn->clientConnection->remote, NULL, NULL, NULL);
         assert(context->http->out.offset == 0);
         context->pullData();
         goto finish;
     }
 
     /* compile headers */
-    if (http_ver.major >= 1 && !request->parseHeader(hp)) {
+    if (hp->messageProtocol().major >= 1 && !request->parseHeader(*hp)) {
         clientStreamNode *node = context->getClientReplyContext();
-        debugs(33, 5, "Failed to parse request headers:\n" << hp.mimeHeader());
+        debugs(33, 5, "Failed to parse request headers:\n" << hp->mimeHeader());
         conn->quitAfterError(request.getRaw());
         // setLogUri should called before repContext->setReplyToError
         setLogUri(http, http->uri,  true);
         clientReplyContext *repContext = dynamic_cast<clientReplyContext *>(node->data.getRaw());
         assert (repContext);
-        repContext->setReplyToError(ERR_INVALID_REQ, Http::scBadRequest, method, http->uri, conn->clientConnection->remote, NULL, NULL, NULL);
+        repContext->setReplyToError(ERR_INVALID_REQ, Http::scBadRequest, hp->method(), http->uri, conn->clientConnection->remote, NULL, NULL, NULL);
         assert(context->http->out.offset == 0);
         context->pullData();
         goto finish;
     }
 
-doFtpAndHttp:
+    }
+
     // Some blobs below are still HTTP-specific, but we would have to rewrite
     // this entire function to remove them from the FTP code path. Connection
     // setup and body_pipe preparation blobs are needed for FTP.
@@ -2629,11 +2624,15 @@ doFtpAndHttp:
 #endif /* FOLLOW_X_FORWARDED_FOR */
     request->my_addr = conn->clientConnection->local;
     request->myportname = conn->port->name;
-    // XXX: for non-HTTP messages instantiate a different HttpMsg child type
-    // for now Squid only supports HTTP requests
-    assert(request->http_ver.protocol == http_ver.protocol);
-    request->http_ver.major = http_ver.major;
-    request->http_ver.minor = http_ver.minor;
+
+    if (!isFtp) {
+        // XXX: for non-HTTP messages instantiate a different HttpMsg child type
+        // for now Squid only supports HTTP requests
+        const AnyP::ProtocolVersion &http_ver = hp->messageProtocol();
+        assert(request->http_ver.protocol == http_ver.protocol);
+        request->http_ver.major = http_ver.major;
+        request->http_ver.minor = http_ver.minor;
+    }
 
     // Link this HttpRequest to ConnStateData relatively early so the following complex handling can use it
     // TODO: this effectively obsoletes a lot of conn->FOO copying. That needs cleaning up later.
@@ -2713,12 +2712,6 @@ doFtpAndHttp:
         request->body_pipe = conn->expectRequestBody(
                                  chunked ? -1 : request->content_length);
 
-        if (!isFtp) {
-            // consume header early so that body pipe gets just the body
-            connNoteUseOfBuffer(conn, http->req_sz);
-            notedUseOfBuffer = true;
-        }
-
         /* Is it too large? */
         if (!chunked && // if chunked, we will check as we accumulate
                 clientIsRequestBodyTooLargeForPolicy(request->content_length)) {
@@ -2821,8 +2814,7 @@ ConnStateData::clientParseRequests()
         if (concurrentRequestQueueFilled())
             break;
 
-        Http::ProtocolVersion http_ver;
-        ClientSocketContext *context = parseOneRequest(http_ver);
+        ClientSocketContext *context = parseOneRequest();
 
         /* status -1 or 1 */
         if (context) {
@@ -2831,7 +2823,7 @@ ConnStateData::clientParseRequests()
                                              CommTimeoutCbPtrFun(clientLifetimeTimeout, context->http));
             commSetConnTimeout(clientConnection, Config.Timeout.lifetime, timeoutCall);
 
-            processParsedRequest(context, *parser_);
+            processParsedRequest(context);
 
             parsed_req = true; // XXX: do we really need to parse everything right NOW ?
 

diff --git a/src/client_side.h b/src/client_side.h
index 7e5031f5c409fc4e8683bd079f40fba50e4ac774..1992f2329b06cd1dfac00619d7eae36afd96b5df 100644 (file)
--- a/src/client_side.h
+++ b/src/client_side.h
@@ -416,10 +416,10 @@ protected:
     void clientPinnedConnectionRead(const CommIoCbParams &io);
 
     /// parse input buffer prefix into a single transfer protocol request
-    virtual ClientSocketContext *parseOneRequest(Http::ProtocolVersion &ver) = 0;
+    virtual ClientSocketContext *parseOneRequest() = 0;
 
     /// start processing a freshly parsed request
-    virtual void processParsedRequest(ClientSocketContext *context, const Http::ProtocolVersion &ver) = 0;
+    virtual void processParsedRequest(ClientSocketContext *context) = 0;
 
     /// returning N allows a pipeline of 1+N requests (see pipeline_prefetch)
     virtual int pipelinePrefetchMax() const;
@@ -490,8 +490,8 @@ CSCB clientSocketRecipient;
 CSD clientSocketDetach;
 
 /* TODO: Move to HttpServer. Warning: Move requires large code nonchanges! */
-ClientSocketContext *parseHttpRequest(ConnStateData *, HttpParser *, HttpRequestMethod *, Http::ProtocolVersion *);
-void clientProcessRequest(ConnStateData *conn, HttpParser *hp, ClientSocketContext *context, const HttpRequestMethod& method, Http::ProtocolVersion http_ver);
-void clientPostHttpsAccept(ConnStateData *connState);
+ClientSocketContext *parseHttpRequest(ConnStateData *, const Http1::RequestParserPointer &);
+void clientProcessRequest(ConnStateData *, const Http1::RequestParserPointer &, ClientSocketContext *);
+void clientPostHttpsAccept(ConnStateData *);
 
 #endif /* SQUID_CLIENTSIDE_H */

diff --git a/src/http/one/Parser.cc b/src/http/one/Parser.cc
index 4dcb99019d959912d4670728855612e82a3b38ed..42e3ad18a27dae614b41b43cdb46c64c358baca7 100644 (file)
--- a/src/http/one/Parser.cc
+++ b/src/http/one/Parser.cc
@@ -38,7 +38,7 @@ Http::One::Parser::getHeaderField(const char *name)
     static const SBuf crlf("\r\n");
 
     while (tok.prefix(p, iso8859Line)) {
-        tok.skip(CharacterSet::LF); // move tokenizer past the LF
+        tok.skipOne(CharacterSet::LF); // move tokenizer past the LF
 
         // header lines must start with the name (case insensitive)
         if (p.substr(0, namelen).caseCmp(name, namelen))
@@ -56,7 +56,7 @@ Http::One::Parser::getHeaderField(const char *name)
 
         // TODO: optimize SBuf::trim to take CharacterSet directly
         ::Parser::Tokenizer t(p);
-        t.skip(CharacterSet::WSP);
+        t.skipAll(CharacterSet::WSP);
         p = t.remaining();
 
         // prevent buffer overrun on char header[];

diff --git a/src/servers/FtpServer.cc b/src/servers/FtpServer.cc
index 3de0dbea1c2c9ee1768e9dd25db7424cfee455d2..353b84c70f483cbbbb3a409ba094c06198b87a1e 100644 (file)
--- a/src/servers/FtpServer.cc
+++ b/src/servers/FtpServer.cc
@@ -18,6 +18,7 @@
 #include "ftp/Elements.h"
 #include "ftp/Parsing.h"
 #include "globals.h"
+#include "http/one/RequestParser.h"
 #include "HttpHdrCc.h"
 #include "ip/tools.h"
 #include "ipc/FdNotes.h"
@@ -141,15 +142,14 @@ Ftp::Server::doProcessRequest()
     } else if (fwd) {
         debugs(33, 4, "forwarding request to server side");
         assert(http->storeEntry() == NULL);
-        clientProcessRequest(this, NULL /*parser*/, context.getRaw(),
-                             request->method, request->http_ver);
+        clientProcessRequest(this, Http1::RequestParserPointer(), context.getRaw());
     } else {
         debugs(33, 4, "will resume processing later");
     }
 }
 
 void
-Ftp::Server::processParsedRequest(ClientSocketContext *context, const Http::ProtocolVersion &)
+Ftp::Server::processParsedRequest(ClientSocketContext *context)
 {
     // Process FTP request asynchronously to make sure FTP
     // data connection accept callback is fired first.
@@ -548,7 +548,7 @@ Ftp::CommandHasPathParameter(const SBuf &cmd)
 /// Parses a single FTP request on the control connection.
 /// Returns NULL on errors and incomplete requests.
 ClientSocketContext *
-Ftp::Server::parseOneRequest(Http::ProtocolVersion &ver)
+Ftp::Server::parseOneRequest()
 {
     // OWS <command> [ RWS <parameter> ] OWS LF
 
@@ -638,9 +638,8 @@ Ftp::Server::parseOneRequest(Http::ProtocolVersion &ver)
         return NULL;
     }
 
-    ver = Http::ProtocolVersion(Ftp::ProtocolVersion().major, Ftp::ProtocolVersion().minor);
     request->flags.ftpNative = true;
-    request->http_ver = ver;
+    request->http_ver = Http::ProtocolVersion(Ftp::ProtocolVersion().major, Ftp::ProtocolVersion().minor);
 
     // Our fake Request-URIs are not distinctive enough for caching to work
     request->flags.cachable = false; // XXX: reset later by maybeCacheable()

diff --git a/src/servers/FtpServer.h b/src/servers/FtpServer.h
index 0b30178e7bc0ad423122c84fdb3bdfb43fd0a933..f230d01305e940b4889226b1825a6c51abe13d0f 100644 (file)
--- a/src/servers/FtpServer.h
+++ b/src/servers/FtpServer.h
@@ -58,8 +58,8 @@ protected:
     friend void StartListening();
 
     /* ConnStateData API */
-    virtual ClientSocketContext *parseOneRequest(Http::ProtocolVersion &ver);
-    virtual void processParsedRequest(ClientSocketContext *context, const Http::ProtocolVersion &ver);
+    virtual ClientSocketContext *parseOneRequest();
+    virtual void processParsedRequest(ClientSocketContext *context);
     virtual void notePeerConnection(Comm::ConnectionPointer conn);
     virtual void clientPinnedConnectionClosed(const CommCloseCbParams &io);
     virtual void handleReply(HttpReply *header, StoreIOBuffer receivedData);

diff --git a/src/servers/HttpServer.cc b/src/servers/HttpServer.cc
index e14369c1d6b75d360f2db678f2c22b0ffbd15331..e1e5803df7f09e86f1cd62d7a8da96d684c7b4b5 100644 (file)
--- a/src/servers/HttpServer.cc
+++ b/src/servers/HttpServer.cc
@@ -7,6 +7,7 @@
 #include "client_side_request.h"
 #include "comm/Write.h"
 #include "HttpHeaderTools.h"
+#include "http/one/RequestParser.h"
 #include "profiler/Profiler.h"
 #include "servers/forward.h"
 #include "SquidConfig.h"
@@ -25,8 +26,8 @@ public:
 
 protected:
     /* ConnStateData API */
-    virtual ClientSocketContext *parseOneRequest(Http::ProtocolVersion &ver);
-    virtual void processParsedRequest(ClientSocketContext *context, const Http::ProtocolVersion &ver);
+    virtual ClientSocketContext *parseOneRequest();
+    virtual void processParsedRequest(ClientSocketContext *context);
     virtual void handleReply(HttpReply *rep, StoreIOBuffer receivedData);
     virtual void writeControlMsgAndCall(ClientSocketContext *context, HttpReply *rep, AsyncCall::Pointer &call);
     virtual time_t idleTimeout() const;
@@ -42,7 +43,7 @@ private:
     void processHttpRequest(ClientSocketContext *const context);
     void handleHttpRequestData();
 
-    HttpParser parser_;
+    Http1::RequestParserPointer parser_;
     HttpRequestMethod method_; ///< parsed HTTP method
 
     /// temporary hack to avoid creating a true HttpsServer class
@@ -103,7 +104,7 @@ Http::Server::noteMoreBodySpaceAvailable(BodyPipe::Pointer)
 }
 
 ClientSocketContext *
-Http::Server::parseOneRequest(Http::ProtocolVersion &ver)
+Http::Server::parseOneRequest()
 {
     PROF_start(HttpServer_parseOneRequest);
 
@@ -114,19 +115,19 @@ Http::Server::parseOneRequest(Http::ProtocolVersion &ver)
         parser_ = new Http1::RequestParser();
 
     /* Process request */
-    ClientSocketContext *context = parseHttpRequest(this, *parser_);
+    ClientSocketContext *context = parseHttpRequest(this, parser_);
 
     PROF_stop(HttpServer_parseOneRequest);
     return context;
 }
 
 void
-Http::Server::processParsedRequest(ClientSocketContext *context, const Http::ProtocolVersion &ver)
+Http::Server::processParsedRequest(ClientSocketContext *context)
 {
     /* We have an initial client stream in place should it be needed */
     /* setup our private context */
     context->registerWithConn();
-    clientProcessRequest(this, &parser_, context, method_, ver);
+    clientProcessRequest(this, parser_, context);
 }
 
 void