HTTP/2 backports for 8.1.x (part 3)

.gitignore

@@ -100,6 +100,7 @@ proxy/hdrs/test_mime
 proxy/hdrs/test_Huffmancode
 proxy/hdrs/test_XPACK
 proxy/http/test_ForwardedConfig
+proxy/http2/test_libhttp2
 proxy/http2/test_Http2DependencyTree
 proxy/http2/test_Http2FrequencyCounter
 proxy/http2/test_HPACK

doc/admin-guide/logging/formatting.en.rst

@@ -185,6 +185,8 @@ Connections and Transactions
 .. _sstc:
 .. _ccid:
 .. _ctid:
+.. _ctpw:
+.. _ctpd:
 
 The following log fields are used to list various details of connections and
 transactions between |TS| proxies and origin servers.
@@ -204,6 +206,10 @@ ctid  Client Request Client Transaction ID, a non-negative number for a transact
                      which is different for all currently-active transactions on the
                      same client connection.  For client HTTP/2 transactions, this
                      value is the stream ID for the transaction.
+ctpw  Client Request Client Transaction Priority Weight, the priority weight for the
+                     underlying HTTP/2 protocol.
+ctpd  Client Request Client Transaction Priority Dependence, the transaction ID that
+                     the current transaction depends on for HTTP/2 priority logic.
 ===== ============== ==================================================================
 
 .. _admin-logging-fields-content-type:

iocore/eventsystem/I_IOBuffer.h

@@ -1184,13 +1184,13 @@ class MIOBuffer
 */
 struct MIOBufferAccessor {
   IOBufferReader *
-  reader()
+  reader() const
   {
     return entry;
   }
 
   MIOBuffer *
-  writer()
+  writer() const
   {
     return mbuf;
   }

iocore/eventsystem/I_VIO.h

@@ -25,17 +25,12 @@
 #pragma once
 #define I_VIO_h
 
-#include "tscore/ink_platform.h"
-#include "I_EventSystem.h"
 #if !defined(I_IOBuffer_h)
 #error "include I_IOBuffer.h"
----include I_IOBuffer.h
 #endif
-#include "tscore/ink_apidefs.h"
-   class Continuation;
+
+class Continuation;
 class VConnection;
-class IOVConnection;
-class MIOBuffer;
 class ProxyMutex;
 
 /**
@@ -73,9 +68,12 @@ class ProxyMutex;
 class VIO
 {
 public:
+  explicit VIO(int aop);
+  VIO();
   ~VIO() {}
+
   /** Interface for the VConnection that owns this handle. */
-  Continuation *get_continuation();
+  Continuation *get_continuation() const;
   void set_continuation(Continuation *cont);
 
   /**
@@ -102,8 +100,8 @@ class VIO
   /////////////////////
   void set_writer(MIOBuffer *writer);
   void set_reader(IOBufferReader *reader);
-  MIOBuffer *get_writer();
-  IOBufferReader *get_reader();
+  MIOBuffer *get_writer() const;
+  IOBufferReader *get_reader() const;
 
   /**
     Reenable the IO operation.
@@ -140,10 +138,7 @@ class VIO
   inkcoreapi void reenable_re();
 
   void disable();
-  bool is_disabled();
-
-  VIO(int aop);
-  VIO();
+  bool is_disabled() const;
 
   enum {
     NONE = 0,
@@ -160,7 +155,6 @@ class VIO
     STAT,
   };
 
-public:
   /**
     Continuation to callback.
 
@@ -225,5 +219,3 @@ class VIO
 private:
   bool _disabled = false;
 };
-
-#include "I_VConnection.h"

iocore/eventsystem/P_VIO.h

@@ -27,44 +27,45 @@
 TS_INLINE
 VIO::VIO(int aop) : cont(nullptr), nbytes(0), ndone(0), op(aop), buffer(), vc_server(nullptr), mutex(nullptr) {}
 
-/////////////////////////////////////////////////////////////
-//
-//  VIO::VIO()
-//
-/////////////////////////////////////////////////////////////
 TS_INLINE
 VIO::VIO() : cont(nullptr), nbytes(0), ndone(0), op(VIO::NONE), buffer(), vc_server(nullptr), mutex(nullptr) {}
 
 TS_INLINE Continuation *
-VIO::get_continuation()
+VIO::get_continuation() const
 {
   return cont;
 }
+
 TS_INLINE void
 VIO::set_writer(MIOBuffer *writer)
 {
   buffer.writer_for(writer);
 }
+
 TS_INLINE void
 VIO::set_reader(IOBufferReader *reader)
 {
   buffer.reader_for(reader);
 }
+
 TS_INLINE MIOBuffer *
-VIO::get_writer()
+VIO::get_writer() const
 {
   return buffer.writer();
 }
+
 TS_INLINE IOBufferReader *
-VIO::get_reader()
+VIO::get_reader() const
 {
   return (buffer.reader());
 }
+
 TS_INLINE int64_t
 VIO::ntodo() const
 {
   return nbytes - ndone;
 }
+
 TS_INLINE void
 VIO::done()
 {
@@ -75,11 +76,6 @@ VIO::done()
   }
 }
 
-/////////////////////////////////////////////////////////////
-//
-//  VIO::set_continuation()
-//
-/////////////////////////////////////////////////////////////
 TS_INLINE void
 VIO::set_continuation(Continuation *acont)
 {
@@ -96,11 +92,6 @@ VIO::set_continuation(Continuation *acont)
   return;
 }
 
-/////////////////////////////////////////////////////////////
-//
-//  VIO::reenable()
-//
-/////////////////////////////////////////////////////////////
 TS_INLINE void
 VIO::reenable()
 {
@@ -110,11 +101,6 @@ VIO::reenable()
   }
 }
 
-/////////////////////////////////////////////////////////////
-//
-//  VIO::reenable_re()
-//
-/////////////////////////////////////////////////////////////
 TS_INLINE void
 VIO::reenable_re()
 {
@@ -131,7 +117,7 @@ VIO::disable()
 }
 
 TS_INLINE bool
-VIO::is_disabled()
+VIO::is_disabled() const
 {
   return this->_disabled;
 }

proxy/ProxyClientTransaction.cc

@@ -115,3 +115,15 @@ ProxyClientTransaction::set_tx_error_code(ProxyError e)
     this->current_reader->t_state.client_info.tx_error_code = e;
   }
 }
+
+int
+ProxyClientTransaction::get_transaction_priority_weight() const
+{
+  return 0;
+}
+
+int
+ProxyClientTransaction::get_transaction_priority_dependence() const
+{
+  return 0;
+}

proxy/ProxyClientTransaction.h

@@ -235,6 +235,8 @@ class ProxyClientTransaction : public VConnection
     return current_reader;
   }
 
+  virtual int get_transaction_priority_weight() const;
+  virtual int get_transaction_priority_dependence() const;
   virtual bool allow_half_open() const = 0;
 
   virtual const char *

proxy/hdrs/HTTP.h

@@ -618,7 +618,7 @@ class HTTPHdr : public MIMEHdr
   /// header internals, they must be able to do this.
   void mark_target_dirty() const;
 
-  HTTPStatus status_get();
+  HTTPStatus status_get() const;
   void status_set(HTTPStatus status);
 
   const char *reason_get(int *length);
@@ -635,6 +635,7 @@ class HTTPHdr : public MIMEHdr
   bool is_cache_control_set(const char *cc_directive_wks);
   bool is_pragma_no_cache_set();
   bool is_keep_alive_set() const;
+  bool expect_final_response() const;
   HTTPKeepAlive keep_alive_get() const;
 
 protected:
@@ -1004,6 +1005,24 @@ HTTPHdr::is_keep_alive_set() const
   return this->keep_alive_get() == HTTP_KEEPALIVE;
 }
 
+/**
+   Check the status code is informational and expecting final response
+   - e.g. "100 Continue", "103 Early Hints"
+
+   Please note that "101 Switching Protocol" is not included.
+ */
+inline bool
+HTTPHdr::expect_final_response() const
+{
+  switch (this->status_get()) {
+  case HTTP_STATUS_CONTINUE:
+  case HTTP_STATUS_EARLY_HINTS:
+    return true;
+  default:
+    return false;
+  }
+}
+
 /*-------------------------------------------------------------------------
   -------------------------------------------------------------------------*/
 
@@ -1154,7 +1173,7 @@ http_hdr_status_get(HTTPHdrImpl *hh)
   -------------------------------------------------------------------------*/
 
 inline HTTPStatus
-HTTPHdr::status_get()
+HTTPHdr::status_get() const
 {
   ink_assert(valid());
 

proxy/http/HttpSM.cc

@@ -432,7 +432,9 @@ HttpSM::attach_client_session(ProxyClientTransaction *client_vc, IOBufferReader
   // It seems to be possible that the ua_txn pointer will go stale before log entries for this HTTP transaction are
   // generated.  Therefore, collect information that may be needed for logging from the ua_txn object at this point.
   //
-  _client_transaction_id = ua_txn->get_transaction_id();
+  _client_transaction_id                  = ua_txn->get_transaction_id();
+  _client_transaction_priority_weight     = ua_txn->get_transaction_priority_weight();
+  _client_transaction_priority_dependence = ua_txn->get_transaction_priority_dependence();
   {
     auto p = ua_txn->get_parent();
 
@@ -2694,6 +2696,8 @@ HttpSM::tunnel_handler_post(int event, void *data)
     handle_post_failure();
     break;
   case HTTP_SM_POST_UA_FAIL:
+    // Client side failed.  Shutdown and go home.  No need to communicate back to UA
+    terminate_sm = true;
     break;
   case HTTP_SM_POST_SUCCESS:
     // It's time to start reading the response
@@ -3439,9 +3443,7 @@ HttpSM::tunnel_handler_post_ua(int event, HttpTunnelProducer *p)
     hsm_release_assert(ua_entry->in_tunnel == true);
     if (p->consumer_list.head && p->consumer_list.head->vc_type == HT_TRANSFORM) {
       hsm_release_assert(post_transform_info.entry->in_tunnel == true);
-    } else if (server_entry != nullptr) {
-      hsm_release_assert(server_entry->in_tunnel == true);
-    }
+    } // server side may have completed before the user agent side, so it may no longer be in tunnel
     break;
 
   case VC_EVENT_READ_COMPLETE:
@@ -3578,7 +3580,8 @@ HttpSM::tunnel_handler_post_server(int event, HttpTunnelConsumer *c)
 
   case VC_EVENT_WRITE_COMPLETE:
     // Completed successfully
-    c->write_success = true;
+    c->write_success        = true;
+    server_entry->in_tunnel = false;
     break;
   default:
     ink_release_assert(0);

proxy/http/HttpSM.h

@@ -617,9 +617,22 @@ class HttpSM : public Continuation
     return _client_transaction_id;
   }
 
+  int
+  client_transaction_priority_weight() const
+  {
+    return _client_transaction_priority_weight;
+  }
+
+  int
+  client_transaction_priority_dependence() const
+  {
+    return _client_transaction_priority_dependence;
+  }
+
 private:
   PostDataBuffers _postbuf;
   int _client_connection_id = -1, _client_transaction_id = -1;
+  int _client_transaction_priority_weight = -1, _client_transaction_priority_dependence = -1;
 };
 
 // Function to get the cache_sm object - YTS Team, yamsat

proxy/http/HttpTransact.cc

@@ -6833,10 +6833,10 @@ HttpTransact::handle_response_keep_alive_headers(State *s, HTTPVersion ver, HTTP
     // to the client to keep the connection alive.
     // Insert a Transfer-Encoding header in the response if necessary.
 
-    // check that the client is HTTP 1.1 and the conf allows chunking or the client
-    // protocol unchunks before returning to the user agent (i.e. is http/2)
-    if (s->client_info.http_version == HTTPVersion(1, 1) && s->txn_conf->chunking_enabled == 1 &&
-        s->state_machine->ua_txn->is_chunked_encoding_supported() &&
+    // check that the client protocol is HTTP/1.1 and the conf allows chunking or
+    // the client protocol doesn't support chunked transfer coding (i.e. HTTP/1.0, HTTP/2)
+    if (s->state_machine->ua_txn && s->state_machine->ua_txn->is_chunked_encoding_supported() &&
+        s->client_info.http_version == HTTPVersion(1, 1) && s->txn_conf->chunking_enabled == 1 &&
         // if we're not sending a body, don't set a chunked header regardless of server response
         !is_response_body_precluded(s->hdr_info.client_response.status_get(), s->method) &&
         // we do not need chunked encoding for internal error messages
@@ -6868,12 +6868,13 @@ HttpTransact::handle_response_keep_alive_headers(State *s, HTTPVersion ver, HTTP
     }
 
     // Close the connection if client_info is not keep-alive.
-    // Otherwise, if we cannot trust the content length and the client process chunked encoding, we will close the connection
-    // unless we are going to use chunked encoding or the client issued
-    // a PUSH request
+    // Otherwise, if we cannot trust the content length, we will close the connection
+    // unless we are going to use chunked encoding on HTTP/1.1 or the client issued a PUSH request
     if (s->client_info.keep_alive != HTTP_KEEPALIVE) {
       ka_action = KA_DISABLED;
-    } else if (s->hdr_info.trust_response_cl == false && s->state_machine->ua_txn->is_chunked_encoding_supported() &&
+    } else if (s->state_machine->client_protocol && (strncmp(s->state_machine->client_protocol, "http/2", 6) == 0)) {
+      ka_action = KA_CONNECTION;
+    } else if (s->hdr_info.trust_response_cl == false &&
                !(s->client_info.receive_chunked_response == true ||
                  (s->method == HTTP_WKSIDX_PUSH && s->client_info.keep_alive == HTTP_KEEPALIVE))) {
       ka_action = KA_CLOSE;