Rewritten spdycl as spdycat.

examples/spdycat.cc

@@ -0,0 +1,236 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/epoll.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <signal.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <iostream>
+#include <string>
+#include <set>
+#include <iomanip>
+#include <fstream>
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <spdylay/spdylay.h>
+
+#include "spdylay_ssl.h"
+#include "uri.h"
+
+namespace spdylay {
+
+std::string target_path;
+int32_t target_stream_id;
+bool debug = false;
+extern bool ssl_debug;
+
+void on_data_chunk_recv_callback
+(spdylay_session *session, uint8_t flags, int32_t stream_id,
+ const uint8_t *data, size_t len, void *user_data)
+{
+  if(!debug && stream_id == target_stream_id) {
+    std::cout.write(reinterpret_cast<const char*>(data), len);
+  }
+}
+
+void check_stream_id(spdylay_frame_type type, spdylay_frame *frame)
+{
+  if(type == SPDYLAY_SYN_STREAM) {
+    for(int i = 0; frame->syn_stream.nv[i]; i += 2) {
+      if(strcmp("url", frame->syn_stream.nv[i]) == 0) {
+        if(target_path == frame->syn_stream.nv[i+1]) {
+          target_stream_id = frame->syn_stream.stream_id;
+        }
+        break;
+      }
+    }
+  }
+}
+
+void on_ctrl_send_callback2
+(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
+ void *user_data)
+{
+  check_stream_id(type, frame);
+}
+
+void on_ctrl_send_callback3
+(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
+ void *user_data)
+{
+  check_stream_id(type, frame);
+  on_ctrl_send_callback(session, type, frame, user_data);
+}
+
+void on_stream_close_callback
+(spdylay_session *session, int32_t stream_id, spdylay_status_code status_code,
+ void *user_data)
+{
+  if(target_stream_id == stream_id) {
+    spdylay_submit_goaway(session);
+  }
+}
+
+int communicate(const std::string& host, uint16_t port,
+                const std::string& path,
+                const spdylay_session_callbacks *callbacks)
+{
+  target_path = path;
+  ssl_debug = debug;
+  int fd = connect_to(host, port);
+  if(fd == -1) {
+    std::cerr << "Could not connect to the host" << std::endl;
+    return -1;
+  }
+  SSL_CTX *ssl_ctx;
+  ssl_ctx = SSL_CTX_new(SSLv23_client_method());
+  if(!ssl_ctx) {
+    std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
+    return -1;
+  }
+  setup_ssl_ctx(ssl_ctx);
+  SSL *ssl = SSL_new(ssl_ctx);
+  if(!ssl) {
+    std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
+    return -1;
+  }
+  if(ssl_handshake(ssl, fd) == -1) {
+    return -1;
+  }
+  make_non_block(fd);
+  Spdylay sc(fd, ssl, callbacks);
+  int epollfd = epoll_create(1);
+  if(epollfd == -1) {
+    perror("epoll_create");
+    return -1;
+  }
+  sc.submit_request(path, 3);
+
+  ctl_epollev(epollfd, EPOLL_CTL_ADD, &sc);
+  static const size_t MAX_EVENTS = 1;
+  epoll_event events[MAX_EVENTS];
+  bool ok = true;
+  while(sc.want_read() || sc.want_write()) {
+    int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
+    if(nfds == -1) {
+      perror("epoll_wait");
+      return -1;
+    }
+    for(int n = 0; n < nfds; ++n) {
+      if(((events[n].events & EPOLLIN) && sc.recv() != 0) ||
+         ((events[n].events & EPOLLOUT) && sc.send() != 0)) {
+        ok = false;
+        std::cout << "Fatal" << std::endl;
+        break;
+      }
+      if((events[n].events & EPOLLHUP) || (events[n].events & EPOLLERR)) {
+        std::cout << "HUP" << std::endl;
+        ok = false;
+        break;
+      }
+    }
+    if(!ok) {
+      break;
+    }
+    ctl_epollev(epollfd, EPOLL_CTL_MOD, &sc);
+  }
+
+  SSL_shutdown(ssl);
+  SSL_free(ssl);
+  SSL_CTX_free(ssl_ctx);
+  shutdown(fd, SHUT_WR);
+  close(fd);
+  return ok ? 0 : -1;
+}
+
+int run(const std::string& host, uint16_t port, const std::string& path)
+{
+  spdylay_session_callbacks callbacks;
+  memset(&callbacks, 0, sizeof(spdylay_session_callbacks));
+  callbacks.send_callback = send_callback;
+  callbacks.recv_callback = recv_callback;
+  callbacks.on_stream_close_callback = on_stream_close_callback;
+  if(debug) {
+    callbacks.on_ctrl_recv_callback = on_ctrl_recv_callback;
+    callbacks.on_data_recv_callback = on_data_recv_callback;
+    callbacks.on_ctrl_send_callback = on_ctrl_send_callback3;
+  } else {
+    callbacks.on_ctrl_send_callback = on_ctrl_send_callback2;
+    callbacks.on_data_chunk_recv_callback = on_data_chunk_recv_callback;
+  }
+  return communicate(host, port, path, &callbacks);
+}
+
+} // namespace spdylay
+
+void print_usage(const char *prog)
+{
+  std::cerr << "Usage: " << prog << " [-d] URI" << std::endl;
+  std::cerr << "   Get the resource identified by URI via spdy/2 protocol and\n"
+            << "   output the resource.\n"
+            << "\n"
+            << "   -d: Output debug information instead of output the resource."
+            << std::endl;
+}
+
+int main(int argc, char **argv)
+{
+  std::string uri;
+  if(argc == 2) {
+    spdylay::debug = false;
+    uri = argv[1];
+  } else if(argc == 3 && strcmp(argv[1], "-d") == 0) {
+    spdylay::debug = true;
+    uri = argv[2];
+  } else {
+    print_usage(basename(argv[0]));
+    exit(EXIT_FAILURE);
+  }
+  struct sigaction act;
+  memset(&act, 0, sizeof(struct sigaction));
+  act.sa_handler = SIG_IGN;
+  sigaction(SIGPIPE, &act, 0);
+  SSL_load_error_strings();
+  SSL_library_init();
+  spdylay::uri::UriStruct us;
+  if(!spdylay::uri::parse(us, uri)) {
+    std::cerr << "Could not parse URI" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+  spdylay::run(us.host, us.port, us.dir+us.file+us.query);
+  return 0;
+}

examples/spdylay_ssl.cc

@@ -30,7 +30,6 @@
 #include <sys/epoll.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
-#include <signal.h>
 
 #include <cassert>
 #include <cstdio>
@@ -44,20 +43,99 @@
 #include <iomanip>
 #include <fstream>
 
-#include <openssl/ssl.h>
+#include "spdylay_ssl.h"
-#include <openssl/err.h>
-#include <spdylay/spdylay.h>
 
-int connect_to(const char *host, const char *service)
+namespace spdylay {
+
+bool ssl_debug = false;
+
+Spdylay::Spdylay(int fd, SSL *ssl, const spdylay_session_callbacks *callbacks)
+  : fd_(fd), ssl_(ssl), want_write_(false)
+{
+  spdylay_session_client_new(&session_, callbacks, this);
+}
+
+Spdylay::~Spdylay()
+{
+  spdylay_session_del(session_);
+}
+
+int Spdylay::recv()
+{
+  return spdylay_session_recv(session_);
+}
+
+int Spdylay::send()
+{
+  return spdylay_session_send(session_);
+}
+
+ssize_t Spdylay::send_data(const uint8_t *data, size_t len, int flags)
+{
+  ssize_t r;
+  r = SSL_write(ssl_, data, len);
+  return r;
+}
+
+ssize_t Spdylay::recv_data(uint8_t *data, size_t len, int flags)
+{
+  ssize_t r;
+  want_write_ = false;
+  r = SSL_read(ssl_, data, len);
+  if(r < 0) {
+    if(SSL_get_error(ssl_, r) == SSL_ERROR_WANT_WRITE) {
+      want_write_ = true;
+    }
+  }
+  return r;
+}
+
+bool Spdylay::want_read()
+{
+  return spdylay_session_want_read(session_);
+}
+
+bool Spdylay::want_write()
+{
+  return spdylay_session_want_write(session_) || want_write_;
+}
+
+int Spdylay::fd() const
+{
+  return fd_;
+}
+
+int Spdylay::submit_request(const std::string& path, uint8_t pri)
+{
+  const char *nv[] = {
+    "method", "GET",
+    "scheme", "https",
+    "url", path.c_str(),
+    "user-agent", "spdylay/0.0.0",
+    "version", "HTTP/1.1",
+    NULL
+  };
+  return spdylay_submit_request(session_, pri, nv, NULL);
+}
+
+bool Spdylay::would_block(int r)
+{
+  int e = SSL_get_error(ssl_, r);
+  return e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_WANT_READ;
+}
+
+int connect_to(const std::string& host, uint16_t port)
 {
   struct addrinfo hints;
   int fd = -1;
   int r;
+  char service[10];
+  snprintf(service, sizeof(service), "%u", port);
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   struct addrinfo *res;
-  r = getaddrinfo(host, service, &hints, &res);
+  r = getaddrinfo(host.c_str(), service, &hints, &res);
   if(r != 0) {
     std::cerr << "getaddrinfo: " << gai_strerror(r) << std::endl;
     return -1;
@@ -93,89 +171,11 @@ int make_non_block(int fd)
   return 0;
 }
 
-class SpdylayClient {
-public:
-  SpdylayClient(int fd, SSL *ssl,
-                const spdylay_session_callbacks *callbacks)
-    : fd_(fd), ssl_(ssl), want_write_(false)
-  {
-    spdylay_session_client_new(&session_, callbacks, this);
-  }
-  ~SpdylayClient()
-  {
-    spdylay_session_del(session_);
-    SSL_shutdown(ssl_);
-    shutdown(fd_, SHUT_WR);
-    close(fd_);
-    SSL_free(ssl_);
-  }
-  int on_read_event()
-  {
-    return spdylay_session_recv(session_);
-  }
-  int on_write_event()
-  {
-    return spdylay_session_send(session_);
-  }
-  ssize_t send_data(const uint8_t *data, size_t len, int flags)
-  {
-    ssize_t r;
-    r = SSL_write(ssl_, data, len);
-    return r;
-  }
-  ssize_t recv_data(uint8_t *data, size_t len, int flags)
-  {
-    ssize_t r;
-    want_write_ = false;
-    r = SSL_read(ssl_, data, len);
-    if(r < 0) {
-      if(SSL_get_error(ssl_, r) == SSL_ERROR_WANT_WRITE) {
-        want_write_ = true;
-      }
-    }
-    return r;
-  }
-  bool want_read()
-  {
-    return spdylay_session_want_read(session_);
-  }
-  bool want_write()
-  {
-    return spdylay_session_want_write(session_) || want_write_;
-  }
-  int fd() const
-  {
-    return fd_;
-  }
-  int submit_request(const char *path)
-  {
-    const char *nv[] = {
-      "method", "GET",
-      "scheme", "https",
-      "url", path,
-      "user-agent", "spdylay/0.0.0",
-      "version", "HTTP/1.1",
-      NULL
-    };
-    return spdylay_submit_request(session_, 3, nv);
-  }
-  bool would_block(int r)
-  {
-    int e = SSL_get_error(ssl_, r);
-    return e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_WANT_READ;
-  }
-private:
-  int fd_;
-  SSL *ssl_;
-  spdylay_session *session_;
-  bool want_write_;
-};
-
 ssize_t send_callback(spdylay_session *session,
                       const uint8_t *data, size_t len, int flags,
                       void *user_data)
 {
-  SpdylayClient *sc = (SpdylayClient*)user_data;
+  Spdylay *sc = (Spdylay*)user_data;
   ssize_t r = sc->send_data(data, len, flags);
   if(r < 0) {
     if(sc->would_block(r)) {
@@ -190,7 +190,7 @@ ssize_t send_callback(spdylay_session *session,
 ssize_t recv_callback(spdylay_session *session,
                       uint8_t *data, size_t len, int flags, void *user_data)
 {
-  SpdylayClient *sc = (SpdylayClient*)user_data;
+  Spdylay *sc = (Spdylay*)user_data;
   ssize_t r = sc->recv_data(data, len, flags);
   if(r < 0) {
     if(sc->would_block(r)) {
@@ -204,14 +204,6 @@ ssize_t recv_callback(spdylay_session *session,
   return r;
 }
 
-void print_nv(char **nv)
-{
-  int i;
-  for(i = 0; nv[i]; i += 2) {
-    printf("  %s: %s\n", nv[i], nv[i+1]);
-  }
-}
-
 static const char *ctrl_names[] = {
   "SYN_STREAM",
   "SYN_REPLY",
@@ -223,6 +215,14 @@ static const char *ctrl_names[] = {
   "HEADERS"
 };
 
+void print_nv(char **nv)
+{
+  int i;
+  for(i = 0; nv[i]; i += 2) {
+    printf("  %s: %s\n", nv[i], nv[i+1]);
+  }
+}
+
 void on_ctrl_recv_callback
 (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
  void *user_data)
@@ -235,26 +235,25 @@ void on_ctrl_recv_callback
            frame->syn_reply.hd.length);
     print_nv(frame->syn_reply.nv);
     break;
+  case SPDYLAY_PING:
+    printf("(unique_id=%d)\n", frame->ping.unique_id);
+    break;
   default:
+    printf("\n");
     break;
   }
   fflush(stdout);
 }
 
-void on_data_chunk_recv_callback
-(spdylay_session *session, uint8_t flags, int32_t stream_id,
- const uint8_t *data, size_t len, void *user_data)
-{}
-
 void on_data_recv_callback
 (spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length,
  void *user_data)
 {
   printf("recv DATA frame (stream_id=%d, flags=%d, length=%d)\n",
          stream_id, flags, length);
-  if(flags & SPDYLAY_FLAG_FIN) {
+  // if(flags & SPDYLAY_FLAG_FIN) {
-    spdylay_submit_goaway(session);
+  //   spdylay_submit_ping(session);
-  }
+  // }
   fflush(stdout);
 }
 
@@ -270,25 +269,30 @@ void on_ctrl_send_callback
            frame->syn_stream.hd.length);
     print_nv(frame->syn_stream.nv);
     break;
+  case SPDYLAY_PING:
+    printf("(unique_id=%d)\n", frame->ping.unique_id);
+    break;
   case SPDYLAY_GOAWAY:
     printf("(last_good_stream_id=%d)\n", frame->goaway.last_good_stream_id);
+    break;
   default:
+    printf("\n");
     break;
   }
   fflush(stdout);
 }
 
-void ctl_epollev(int epollfd, int op, SpdylayClient& sc)
+void ctl_epollev(int epollfd, int op, Spdylay *sc)
 {
   epoll_event ev;
   memset(&ev, 0, sizeof(ev));
-  if(sc.want_read()) {
+  if(sc->want_read()) {
     ev.events |= EPOLLIN;
   }
-  if(sc.want_write()) {
+  if(sc->want_write()) {
     ev.events |= EPOLLOUT;
   }
-  if(epoll_ctl(epollfd, op, sc.fd(), &ev) == -1) {
+  if(epoll_ctl(epollfd, op, sc->fd(), &ev) == -1) {
     perror("epoll_ctl");
     exit(EXIT_FAILURE);
   }
@@ -301,143 +305,44 @@ int select_next_proto_cb(SSL* ssl,
 {
   *out = (unsigned char*)in+1;
   *outlen = in[0];
-  std::cout << "NPN select next proto: server offers:" << std::endl;
+  if(ssl_debug) {
+    std::cout << "NPN select next proto: server offers:" << std::endl;
+  }
   for(unsigned int i = 0; i < inlen; i += in[i]+1) {
-    std::cout << "* " << std::string(&in[i+1], &in[i+1]+in[i]) << std::endl;
+    if(ssl_debug) {
+      std::cout << "  * ";
+      std::cout.write(reinterpret_cast<const char*>(&in[i+1]), in[i]);
+      std::cout << std::endl;
+    }
     if(in[i] == 6 && memcmp(&in[i+1], "spdy/2", in[i]) == 0) {
       *out = (unsigned char*)in+i+1;
       *outlen = in[i];
     }
   }
   return SSL_TLSEXT_ERR_OK;
-
-
-  int status = SSL_select_next_proto(out, outlen, in, inlen,
-                                     (const unsigned char*)"spdy/2", 6);
-  switch(status) {
-  case OPENSSL_NPN_UNSUPPORTED:
-    std::cerr << "npn unsupported" << std::endl;
-    break;
-  case OPENSSL_NPN_NEGOTIATED:
-    std::cout << "npn negotiated" << std::endl;
-    break;
-  case OPENSSL_NPN_NO_OVERLAP:
-    std::cout << "npn no overlap" << std::endl;
-    break;
-  default:
-    std::cout << "not reached?" << std::endl;
-  }
-  return SSL_TLSEXT_ERR_OK;
 }
 
-int communicate(const char *host, const char *service, const char *path,
+void setup_ssl_ctx(SSL_CTX *ssl_ctx)
-                const spdylay_session_callbacks *callbacks)
 {
-  int r;
-  int fd = connect_to(host, service);
-  if(fd == -1) {
-    std::cerr << "Could not connect to the host" << std::endl;
-    return -1;
-  }
-  SSL_CTX *ssl_ctx;
-  ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-  if(!ssl_ctx) {
-    std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
-    return -1;
-  }
   /* Disable SSLv2 and enable all workarounds for buggy servers */
   SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2);
   SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
   SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
   SSL_CTX_set_next_proto_select_cb(ssl_ctx, select_next_proto_cb, 0);
+}
 
-  SSL *ssl = SSL_new(ssl_ctx);
+int ssl_handshake(SSL *ssl, int fd)
-  if(!ssl) {
+{
-    std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
-    return -1;
-  }
-
   if(SSL_set_fd(ssl, fd) == 0) {
     std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
     return -1;
   }
-  r = SSL_connect(ssl);
+  int r = SSL_connect(ssl);
   if(r <= 0) {
     std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
     return -1;
   }
-
-  make_non_block(fd);
-  SpdylayClient sc(fd, ssl, callbacks);
-  int epollfd = epoll_create(1);
-  if(epollfd == -1) {
-    perror("epoll_create");
-    return -1;
-  }
-
-  sc.submit_request(path);
-
-  ctl_epollev(epollfd, EPOLL_CTL_ADD, sc);
-  static const size_t MAX_EVENTS = 1;
-  epoll_event events[MAX_EVENTS];
-  bool ok = true;
-  while(sc.want_read() || sc.want_write()) {
-    int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
-    if(nfds == -1) {
-      perror("epoll_wait");
-      return -1;
-    }
-    for(int n = 0; n < nfds; ++n) {
-      if(((events[n].events & EPOLLIN) && sc.on_read_event() != 0) ||
-         ((events[n].events & EPOLLOUT) && sc.on_write_event() != 0)) {
-        ok = false;
-        std::cout << "Fatal" << std::endl;
-        break;
-      }
-      if((events[n].events & EPOLLHUP) || (events[n].events & EPOLLERR)) {
-        std::cout << "HUP" << std::endl;
-        ok = false;
-        break;
-      }
-    }
-    if(!ok) {
-      break;
-    }
-    ctl_epollev(epollfd, EPOLL_CTL_MOD, sc);
-  }
-
-
-  return ok ? 0 : -1;
-}
-
-int run(const char *host, const char *service, const char *path)
-{
-  spdylay_session_callbacks callbacks;
-  memset(&callbacks, 0, sizeof(spdylay_session_callbacks));
-  callbacks.send_callback = send_callback;
-  callbacks.recv_callback = recv_callback;
-  callbacks.on_ctrl_recv_callback = on_ctrl_recv_callback;
-  callbacks.on_data_chunk_recv_callback = on_data_chunk_recv_callback;
-  callbacks.on_data_recv_callback = on_data_recv_callback;
-  callbacks.on_ctrl_send_callback = on_ctrl_send_callback;
-  return communicate(host, service, path, &callbacks);
-}
-
-int main(int argc, char **argv)
-{
-  if(argc < 2) {
-    std::cerr << "Usage: " << argv[0] << " HOST PORT PATH" << std::endl;
-    exit(EXIT_FAILURE);
-  }
-  struct sigaction act;
-  memset(&act, 0, sizeof(struct sigaction));
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGPIPE, &act, 0);
-  const char *host = argv[1];
-  const char *service = argv[2];
-  const char *path = argv[3];
-  SSL_load_error_strings();
-  SSL_library_init();
-  run(host, service, path);
   return 0;
 }
+
+} // namespace spdylay

examples/spdylay_ssl.h

@@ -0,0 +1,98 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef SPDYLAY_SSL_H
+#define SPDYLAY_SSL_H
+
+#include <stdint.h>
+#include <cstdlib>
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <spdylay/spdylay.h>
+
+namespace spdylay {
+
+extern bool ssl_debug;
+
+class Spdylay {
+public:
+  Spdylay(int fd, SSL *ssl, const spdylay_session_callbacks *callbacks);
+  ~Spdylay();
+  int recv();
+  int send();
+  ssize_t send_data(const uint8_t *data, size_t len, int flags);
+  ssize_t recv_data(uint8_t *data, size_t len, int flags);
+  bool want_read();
+  bool want_write();
+  int fd() const;
+  int submit_request(const std::string& path, uint8_t pri);
+  bool would_block(int r);
+private:
+  int fd_;
+  SSL *ssl_;
+  spdylay_session *session_;
+  bool want_write_;
+  bool debug_;
+};
+
+int connect_to(const std::string& host, uint16_t port);
+
+int make_non_block(int fd);
+
+ssize_t send_callback(spdylay_session *session,
+                      const uint8_t *data, size_t len, int flags,
+                      void *user_data);
+
+ssize_t recv_callback(spdylay_session *session,
+                      uint8_t *data, size_t len, int flags, void *user_data);
+
+void print_nv(char **nv);
+
+void on_ctrl_recv_callback
+(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
+ void *user_data);
+
+void on_data_recv_callback
+(spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length,
+ void *user_data);
+
+void on_ctrl_send_callback
+(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
+ void *user_data);
+
+void ctl_epollev(int epollfd, int op, Spdylay *sc);
+
+int select_next_proto_cb(SSL* ssl,
+                         unsigned char **out, unsigned char *outlen,
+                         const unsigned char *in, unsigned int inlen,
+                         void *arg);
+
+void setup_ssl_ctx(SSL_CTX *ssl_ctx);
+
+int ssl_handshake(SSL *ssl, int fd);
+
+} // namespace spdylay
+
+#endif // SPDYLAY_SSL_H

examples/uri.cc

@@ -0,0 +1,330 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "uri.h"
+
+#include <cerrno>
+#include <cstdio>
+#include <vector>
+
+#include "util.h"
+
+namespace spdylay {
+
+namespace uri {
+
+UriStruct::UriStruct()
+  : port(0), hasPassword(false), ipv6LiteralAddress(false)
+{}
+
+UriStruct::UriStruct(const UriStruct& c)
+  : protocol(c.protocol),
+    host(c.host),
+    port(c.port),
+    dir(c.dir),
+    file(c.file),
+    query(c.query),
+    username(c.username),
+    password(c.password),
+    hasPassword(c.hasPassword),
+    ipv6LiteralAddress(c.ipv6LiteralAddress)
+{}
+
+UriStruct::~UriStruct() {}
+
+UriStruct& UriStruct::operator=(const UriStruct& c)
+{
+  if(this != &c) {
+    protocol = c.protocol;
+    host = c.host;
+    port = c.port;
+    dir = c.dir;
+    file = c.file;
+    query = c.query;
+    username = c.username;
+    password = c.password;
+    hasPassword = c.hasPassword;
+    ipv6LiteralAddress = c.ipv6LiteralAddress;
+  }
+  return *this;
+}
+
+void UriStruct::swap(UriStruct& other)
+{
+  using std::swap;
+  if(this != &other) {
+    swap(protocol, other.protocol);
+    swap(host, other.host);
+    swap(port, other.port);
+    swap(dir, other.dir);
+    swap(file, other.file);
+    swap(query, other.query);
+    swap(username, other.username);
+    swap(password, other.password);
+    swap(hasPassword, other.hasPassword);
+    swap(ipv6LiteralAddress, other.ipv6LiteralAddress);
+  }
+}
+
+void swap(UriStruct& lhs, UriStruct& rhs)
+{
+  lhs.swap(rhs);
+}
+
+bool parse(UriStruct& result, const std::string& uri)
+{
+  // http://user:password@aria2.sourceforge.net:80/dir/file?query#fragment
+  //        |            ||                    || |    |   |     |
+  //        |            ||             hostLast| |    |   |     |
+  //        |            ||              portFirst|    |   |     |
+  //    authorityFirst   ||             authorityLast  |   |     |
+  //                     ||                       |    |   |     |
+  //                   userInfoLast               |    |   |     |
+  //                      |                       |    |   |     |
+  //                     hostPortFirst            |    |   |     |
+  //                                              |    |   |     |
+  //                                       dirFirst dirLast|     |
+  //                                                       |     |
+  //                                                queryFirst fragmentFirst
+
+  // find fragment part
+  std::string::const_iterator fragmentFirst = uri.begin();
+  for(; fragmentFirst != uri.end(); ++fragmentFirst) {
+    if(*fragmentFirst == '#') break;
+  }
+  // find query part
+  std::string::const_iterator queryFirst = uri.begin();
+  for(; queryFirst != fragmentFirst; ++queryFirst) {
+    if(*queryFirst == '?') break;
+  }
+  result.query.assign(queryFirst, fragmentFirst);
+  // find protocol
+  std::string::size_type protocolOffset = uri.find("://");
+  if(protocolOffset == std::string::npos) return false;
+  result.protocol.assign(uri.begin(), uri.begin()+protocolOffset);
+  uint16_t defPort;
+  if(result.protocol == "http") {
+    defPort = 80;
+  } else if(result.protocol == "https") {
+    defPort = 443;
+  } else {
+    return false;
+  }
+  // find authority
+  std::string::const_iterator authorityFirst = uri.begin()+protocolOffset+3;
+  std::string::const_iterator authorityLast = authorityFirst;
+  for(; authorityLast != queryFirst; ++authorityLast) {
+    if(*authorityLast == '/') break;
+  }
+  if(authorityFirst == authorityLast) {
+    // No authority found
+    return false;
+  }
+  // find userinfo(username and password) in authority if they exist
+  result.username = "";
+  result.password = "";
+  result.hasPassword = false;
+  std::string::const_iterator userInfoLast = authorityLast;
+  std::string::const_iterator hostPortFirst = authorityFirst;
+  for(; userInfoLast != authorityFirst-1; --userInfoLast) {
+    if(*userInfoLast == '@') {
+      hostPortFirst = userInfoLast;
+      ++hostPortFirst;
+      std::string::const_iterator userLast = authorityFirst;
+      for(; userLast != userInfoLast; ++userLast) {
+        if(*userLast == ':') {
+          result.password =
+            util::percentDecode(userLast+1,userInfoLast);
+          result.hasPassword = true;
+          break;
+        }
+      }
+      result.username =
+        util::percentDecode(authorityFirst, userLast);
+      break;
+    }
+  }
+  std::string::const_iterator hostLast = hostPortFirst;
+  std::string::const_iterator portFirst = authorityLast;
+  result.ipv6LiteralAddress = false;
+  if(*hostPortFirst == '[') {
+    // Detected IPv6 literal address in square brackets
+    for(; hostLast != authorityLast; ++hostLast) {
+      if(*hostLast == ']') {
+        ++hostLast;
+        if(hostLast == authorityLast) {
+          result.ipv6LiteralAddress = true;
+        } else {
+          if(*hostLast == ':') {
+            portFirst = hostLast;
+            ++portFirst;
+            result.ipv6LiteralAddress = true;
+          }
+        }
+        break;
+      }
+    }
+    if(!result.ipv6LiteralAddress) {
+      return false;
+    }
+  } else {
+    for(; hostLast != authorityLast; ++hostLast) {
+      if(*hostLast == ':') {
+        portFirst = hostLast;
+        ++portFirst;
+        break;
+      }
+    }
+  }
+  if(hostPortFirst == hostLast) {
+    // No host
+    return false;
+  }
+  if(portFirst == authorityLast) {
+    // If port is not specified, then we set it to default port of
+    // its protocol..
+    result.port = defPort;
+  } else {
+    errno = 0;
+    uint32_t tempPort = strtol(std::string(portFirst, authorityLast).c_str(),
+                               0, 10);
+    if(errno != 0) {
+      return false;
+    } else if(65535 < tempPort) {
+      return false;
+    }
+  }
+  if(result.ipv6LiteralAddress) {
+    result.host.assign(hostPortFirst+1, hostLast-1);
+  } else {
+    result.host.assign(hostPortFirst, hostLast);
+  }
+  // find directory and file part
+  std::string::const_iterator dirLast = authorityLast;
+  for(std::string::const_iterator i = authorityLast;
+      i != queryFirst; ++i) {
+    if(*i == '/') {
+      dirLast = i+1;
+    }
+  }
+  if(dirLast == queryFirst) {
+    result.file = "";
+  } else {
+    result.file.assign(dirLast, queryFirst);
+  }
+  // dirFirst == authorityLast
+  if(authorityLast == dirLast) {
+    result.dir = "/";
+  } else {
+    result.dir.assign(authorityLast, dirLast);
+  }
+  return true;
+}
+
+std::string construct(const UriStruct& us)
+{
+  std::string res;
+  res += us.protocol;
+  res += "://";
+  if(!us.username.empty()) {
+    res += util::percentEncode(us.username);
+    if(us.hasPassword) {
+      res += ":";
+      res += util::percentEncode(us.password);
+    }
+    res += "@";
+  }
+  if(us.ipv6LiteralAddress) {
+    res += "[";
+    res += us.host;
+    res += "]";
+  } else {
+    res += us.host;
+  }
+  uint16_t defPort;
+  if(us.protocol == "http") {
+    defPort = 80;
+  } else if(us.protocol == "https") {
+    defPort = 443;
+  } else {
+    defPort = 0;
+  }
+  if(us.port != 0 && defPort != us.port) {
+    char temp[10];
+    snprintf(temp, sizeof(temp), ":%u", us.port);
+    res += temp;
+  }
+  res += us.dir;
+  if(us.dir.empty() || us.dir[us.dir.size()-1] != '/') {
+    res += "/";
+  }
+  res += us.file;
+  res += us.query;
+  return res;
+}
+
+std::string joinUri(const std::string& baseUri, const std::string& uri)
+{
+  UriStruct us;
+  if(parse(us, uri)) {
+    return uri;
+  } else {
+    UriStruct bus;
+    if(!parse(bus, baseUri)) {
+      return uri;
+    }
+    std::vector<std::string> parts;
+    if(uri.empty() || uri[0] != '/') {
+      util::split(bus.dir.begin(), bus.dir.end(), std::back_inserter(parts),
+                  '/');
+    }
+    std::string::const_iterator qend;
+    for(qend = uri.begin(); qend != uri.end(); ++qend) {
+      if(*qend == '#') {
+        break;
+      }
+    }
+    std::string::const_iterator end;
+    for(end = uri.begin(); end != qend; ++end) {
+      if(*end == '?') {
+        break;
+      }
+    }
+    util::split(uri.begin(), end, std::back_inserter(parts), '/');
+    bus.dir.clear();
+    bus.file.clear();
+    bus.query.clear();
+    std::string res = construct(bus);
+    res += util::joinPath(parts.begin(), parts.end());
+    if((uri.begin() == end || *(end-1) == '/') && *(res.end()-1) != '/') {
+      res += "/";
+    }
+    res.append(end, qend);
+    return res;
+  }
+}
+
+} // namespace uri
+
+} // namespace spdylay

examples/uri.h

@@ -0,0 +1,71 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef URI_H
+#define URI_H
+
+#include <stdint.h>
+
+#include <string>
+
+namespace spdylay {
+
+namespace uri {
+
+struct UriStruct {
+  std::string protocol;
+  std::string host;
+  uint16_t port;
+  std::string dir;
+  std::string file;
+  std::string query;
+  std::string username;
+  std::string password;
+  bool hasPassword;
+  bool ipv6LiteralAddress;
+
+  UriStruct();
+  UriStruct(const UriStruct& c);
+  ~UriStruct();
+
+  UriStruct& operator=(const UriStruct& c);
+  void swap(UriStruct& other);
+};
+
+void swap(UriStruct& lhs, UriStruct& rhs);
+
+// Splits URI uri into components and stores them into result.  On
+// success returns true. Otherwise returns false and result is
+// undefined.
+bool parse(UriStruct& result, const std::string& uri);
+
+std::string construct(const UriStruct& us);
+
+std::string joinUri(const std::string& baseUri, const std::string& uri);
+
+} // namespace uri
+
+} // namespace spdylay
+
+#endif // URI_H

examples/util.cc

@@ -0,0 +1,102 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "util.h"
+
+#include <cstdio>
+
+namespace spdylay {
+
+namespace util {
+
+const std::string DEFAULT_STRIP_CHARSET("\r\n\t ");
+
+bool isAlpha(const char c)
+{
+  return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
+}
+
+bool isDigit(const char c)
+{
+  return '0' <= c && c <= '9';
+}
+
+bool isHexDigit(const char c)
+{
+  return isDigit(c) || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f');
+}
+
+bool inRFC3986UnreservedChars(const char c)
+{
+  static const char unreserved[] = { '-', '.', '_', '~' };
+  return isAlpha(c) || isDigit(c) ||
+    std::find(&unreserved[0], &unreserved[4], c) != &unreserved[4];
+}
+
+std::string percentEncode(const unsigned char* target, size_t len)
+{
+  std::string dest;
+  for(size_t i = 0; i < len; ++i) {
+    if(inRFC3986UnreservedChars(target[i])) {
+      dest += target[i];
+    } else {
+      char temp[4];
+      snprintf(temp, sizeof(temp), "%%%02X", target[i]);
+      dest.append(temp);
+      //dest.append(fmt("%%%02X", target[i]));
+    }
+  }
+  return dest;
+}
+
+std::string percentEncode(const std::string& target)
+{
+  return percentEncode(reinterpret_cast<const unsigned char*>(target.c_str()),
+                       target.size());
+}
+
+std::string percentDecode
+(std::string::const_iterator first, std::string::const_iterator last)
+{
+  std::string result;
+  for(; first != last; ++first) {
+    if(*first == '%') {
+      if(first+1 != last && first+2 != last &&
+         isHexDigit(*(first+1)) && isHexDigit(*(first+2))) {
+        std::string numstr(first+1, first+3);
+        result += strtol(numstr.c_str(), 0, 16);
+        first += 2;
+      } else {
+        result += *first;
+      }
+    } else {
+      result += *first;
+    }
+  }
+  return result;
+}
+
+} // namespace util
+
+} // namespace spdylay

examples/util.h

@@ -0,0 +1,168 @@
+/*
+ * Spdylay - SPDY Library
+ *
+ * Copyright (c) 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef UTIL_H
+#define UTIL_H
+
+#include <vector>
+#include <string>
+#include <algorithm>
+
+namespace spdylay {
+
+namespace util {
+
+extern const std::string DEFAULT_STRIP_CHARSET;
+
+template<typename InputIterator>
+std::pair<InputIterator, InputIterator> stripIter
+(InputIterator first, InputIterator last,
+ const std::string& chars = DEFAULT_STRIP_CHARSET)
+{
+  for(; first != last &&
+        std::find(chars.begin(), chars.end(), *first) != chars.end(); ++first);
+  if(first == last) {
+    return std::make_pair(first, last);
+  }
+  InputIterator left = last-1;
+  for(; left != first &&
+        std::find(chars.begin(), chars.end(), *left) != chars.end(); --left);
+  return std::make_pair(first, left+1);
+}
+
+template<typename InputIterator, typename OutputIterator>
+OutputIterator splitIter
+(InputIterator first,
+ InputIterator last,
+ OutputIterator out,
+ char delim,
+ bool doStrip = false,
+ bool allowEmpty = false)
+{
+  for(InputIterator i = first; i != last;) {
+    InputIterator j = std::find(i, last, delim);
+    std::pair<InputIterator, InputIterator> p(i, j);
+    if(doStrip) {
+      p = stripIter(i, j);
+    }
+    if(allowEmpty || p.first != p.second) {
+      *out++ = p;
+    }
+    i = j;
+    if(j != last) {
+      ++i;
+    }
+  }
+  if(allowEmpty &&
+     (first == last || *(last-1) == delim)) {
+    *out++ = std::make_pair(last, last);
+  }
+  return out;
+}
+
+template<typename InputIterator, typename OutputIterator>
+OutputIterator split
+(InputIterator first,
+ InputIterator last,
+ OutputIterator out,
+ char delim,
+ bool doStrip = false,
+ bool allowEmpty = false)
+{
+  for(InputIterator i = first; i != last;) {
+    InputIterator j = std::find(i, last, delim);
+    std::pair<InputIterator, InputIterator> p(i, j);
+    if(doStrip) {
+      p = stripIter(i, j);
+    }
+    if(allowEmpty || p.first != p.second) {
+      *out++ = std::string(p.first, p.second);
+    }
+    i = j;
+    if(j != last) {
+      ++i;
+    }
+  }
+  if(allowEmpty &&
+     (first == last || *(last-1) == delim)) {
+    *out++ = std::string(last, last);
+  }
+  return out;
+}
+
+template<typename InputIterator, typename DelimiterType>
+std::string strjoin(InputIterator first, InputIterator last,
+                    const DelimiterType& delim)
+{
+  std::string result;
+  if(first == last) {
+    return result;
+  }
+  InputIterator beforeLast = last-1;
+  for(; first != beforeLast; ++first) {
+    result += *first;
+    result += delim;
+  }
+  result += *beforeLast;
+  return result;
+}
+
+template<typename InputIterator>
+std::string joinPath(InputIterator first, InputIterator last)
+{
+  std::vector<std::string> elements;
+  for(;first != last; ++first) {
+    if(*first == "..") {
+      if(!elements.empty()) {
+        elements.pop_back();
+      }
+    } else if(*first == ".") {
+      // do nothing
+    } else {
+      elements.push_back(*first);
+    }
+  }
+  return strjoin(elements.begin(), elements.end(), "/");
+}
+
+bool isAlpha(const char c);
+
+bool isDigit(const char c);
+
+bool isHexDigit(const char c);
+
+bool inRFC3986UnreservedChars(const char c);
+
+std::string percentEncode(const unsigned char* target, size_t len);
+
+std::string percentEncode(const std::string& target);
+
+std::string percentDecode
+(std::string::const_iterator first, std::string::const_iterator last);
+
+} // namespace util
+
+} // namespace spdylay
+
+#endif // UTIL_H