ceph/src/jaegertracing/opentelemetry-cpp/third_party/prometheus-cpp/3rdparty/civetweb/examples/embedded_cpp/embedded_cpp.cpp

   1 /* Copyright (c) 2013-2018 the Civetweb developers
   2  * Copyright (c) 2013 No Face Press, LLC
   3  * License http://opensource.org/licenses/mit-license.php MIT License
   4  */
   5
   6 // Simple example program on how to use Embedded C++ interface.
   7
   8 #include "CivetServer.h"
   9 #include <cstring>
  10
  11 #ifdef _WIN32
  12 #include <windows.h>
  13 #else
  14 #include <unistd.h>
  15 #endif
  16
  17 #define DOCUMENT_ROOT "."
  18 #define PORT "8081"
  19 #define EXAMPLE_URI "/example"
  20 #define EXIT_URI "/exit"
  21
  22
  23 /* Exit flag for main loop */
  24 volatile bool exitNow = false;
  25
  26
  27 class ExampleHandler : public CivetHandler
  28 {
  29   public:
  30         bool
  31         handleGet(CivetServer *server, struct mg_connection *conn)
  32         {
  33                 mg_printf(conn,
  34                           "HTTP/1.1 200 OK\r\nContent-Type: "
  35                           "text/html\r\nConnection: close\r\n\r\n");
  36                 mg_printf(conn, "<html><body>\r\n");
  37                 mg_printf(conn,
  38                           "<h2>This is an example text from a C++ handler</h2>\r\n");
  39                 mg_printf(conn,
  40                           "<p>To see a page from the A handler <a "
  41                           "href=\"a\">click here</a></p>\r\n");
  42                 mg_printf(conn,
  43                   "<form action=\"a\" method=\"get\">"
  44                   "To see a page from the A handler with a parameter "
  45                   "<input type=\"submit\" value=\"click here\" "
  46                   "name=\"param\" \\> (GET)</form>\r\n");
  47         mg_printf(conn,
  48                   "<form action=\"a\" method=\"post\">"
  49                   "To see a page from the A handler with a parameter "
  50                   "<input type=\"submit\" value=\"click here\" "
  51                   "name=\"param\" \\> (POST)</form>\r\n");
  52                 mg_printf(conn,
  53                           "<p>To see a page from the A/B handler <a "
  54                           "href=\"a/b\">click here</a></p>\r\n");
  55                 mg_printf(conn,
  56                           "<p>To see a page from the *.foo handler <a "
  57                           "href=\"xy.foo\">click here</a></p>\r\n");
  58                 mg_printf(conn,
  59                           "<p>To see a page from the WebSocket handler <a "
  60                           "href=\"ws\">click here</a></p>\r\n");
  61                 mg_printf(conn,
  62                           "<p>To exit <a href=\"%s\">click here</a></p>\r\n",
  63                           EXIT_URI);
  64                 mg_printf(conn, "</body></html>\r\n");
  65                 return true;
  66         }
  67 };
  68
  69 class ExitHandler : public CivetHandler
  70 {
  71   public:
  72         bool
  73         handleGet(CivetServer *server, struct mg_connection *conn)
  74         {
  75                 mg_printf(conn,
  76                           "HTTP/1.1 200 OK\r\nContent-Type: "
  77                           "text/plain\r\nConnection: close\r\n\r\n");
  78                 mg_printf(conn, "Bye!\n");
  79                 exitNow = true;
  80                 return true;
  81         }
  82 };
  83
  84 class AHandler : public CivetHandler
  85 {
  86   private:
  87         bool
  88         handleAll(const char *method,
  89                   CivetServer *server,
  90                   struct mg_connection *conn)
  91         {
  92                 std::string s = "";
  93                 mg_printf(conn,
  94                           "HTTP/1.1 200 OK\r\nContent-Type: "
  95                           "text/html\r\nConnection: close\r\n\r\n");
  96                 mg_printf(conn, "<html><body>");
  97                 mg_printf(conn, "<h2>This is the A handler for \"%s\" !</h2>", method);
  98                 if (CivetServer::getParam(conn, "param", s)) {
  99                         mg_printf(conn, "<p>param set to %s</p>", s.c_str());
 100                 } else {
 101                         mg_printf(conn, "<p>param not set</p>");
 102                 }
 103                 mg_printf(conn, "</body></html>\n");
 104                 return true;
 105         }
 106
 107   public:
 108         bool
 109         handleGet(CivetServer *server, struct mg_connection *conn)
 110         {
 111                 return handleAll("GET", server, conn);
 112         }
 113         bool
 114         handlePost(CivetServer *server, struct mg_connection *conn)
 115         {
 116                 return handleAll("POST", server, conn);
 117         }
 118 };
 119
 120 class ABHandler : public CivetHandler
 121 {
 122   public:
 123         bool
 124         handleGet(CivetServer *server, struct mg_connection *conn)
 125         {
 126                 mg_printf(conn,
 127                           "HTTP/1.1 200 OK\r\nContent-Type: "
 128                           "text/html\r\nConnection: close\r\n\r\n");
 129                 mg_printf(conn, "<html><body>");
 130                 mg_printf(conn, "<h2>This is the AB handler!!!</h2>");
 131                 mg_printf(conn, "</body></html>\n");
 132                 return true;
 133         }
 134 };
 135
 136 class FooHandler : public CivetHandler
 137 {
 138   public:
 139         bool
 140         handleGet(CivetServer *server, struct mg_connection *conn)
 141         {
 142                 /* Handler may access the request info using mg_get_request_info */
 143                 const struct mg_request_info *req_info = mg_get_request_info(conn);
 144
 145                 mg_printf(conn,
 146                           "HTTP/1.1 200 OK\r\nContent-Type: "
 147                           "text/html\r\nConnection: close\r\n\r\n");
 148
 149                 mg_printf(conn, "<html><body>\n");
 150                 mg_printf(conn, "<h2>This is the Foo GET handler!!!</h2>\n");
 151                 mg_printf(conn,
 152                           "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>\n",
 153                           req_info->request_method,
 154                           req_info->request_uri,
 155                           req_info->http_version);
 156                 mg_printf(conn, "</body></html>\n");
 157
 158                 return true;
 159         }
 160         bool
 161         handlePost(CivetServer *server, struct mg_connection *conn)
 162         {
 163                 /* Handler may access the request info using mg_get_request_info */
 164                 const struct mg_request_info *req_info = mg_get_request_info(conn);
 165                 long long rlen, wlen;
 166                 long long nlen = 0;
 167                 long long tlen = req_info->content_length;
 168                 char buf[1024];
 169
 170                 mg_printf(conn,
 171                           "HTTP/1.1 200 OK\r\nContent-Type: "
 172                           "text/html\r\nConnection: close\r\n\r\n");
 173
 174                 mg_printf(conn, "<html><body>\n");
 175                 mg_printf(conn, "<h2>This is the Foo POST handler!!!</h2>\n");
 176                 mg_printf(conn,
 177                           "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>\n",
 178                           req_info->request_method,
 179                           req_info->request_uri,
 180                           req_info->http_version);
 181                 mg_printf(conn, "<p>Content Length: %li</p>\n", (long)tlen);
 182                 mg_printf(conn, "<pre>\n");
 183
 184                 while (nlen < tlen) {
 185                         rlen = tlen - nlen;
 186                         if (rlen > sizeof(buf)) {
 187                                 rlen = sizeof(buf);
 188                         }
 189                         rlen = mg_read(conn, buf, (size_t)rlen);
 190                         if (rlen <= 0) {
 191                                 break;
 192                         }
 193                         wlen = mg_write(conn, buf, (size_t)rlen);
 194                         if (wlen != rlen) {
 195                                 break;
 196                         }
 197                         nlen += wlen;
 198                 }
 199
 200                 mg_printf(conn, "\n</pre>\n");
 201                 mg_printf(conn, "</body></html>\n");
 202
 203                 return true;
 204         }
 205
 206     #define fopen_recursive fopen
 207
 208     bool
 209         handlePut(CivetServer *server, struct mg_connection *conn)
 210     {
 211         /* Handler may access the request info using mg_get_request_info */
 212         const struct mg_request_info *req_info = mg_get_request_info(conn);
 213         long long rlen, wlen;
 214         long long nlen = 0;
 215         long long tlen = req_info->content_length;
 216         FILE * f;
 217         char buf[1024];
 218         int fail = 0;
 219
 220 #ifdef _WIN32
 221         _snprintf(buf, sizeof(buf), "D:\\somewhere\\%s\\%s", req_info->remote_user, req_info->local_uri);
 222         buf[sizeof(buf)-1] = 0;
 223         if (strlen(buf)>255) {
 224             /* Windows will not work with path > 260 (MAX_PATH), unless we use
 225              * the unicode API. However, this is just an example code: A real
 226              * code will probably never store anything to D:\\somewhere and
 227              * must be adapted to the specific needs anyhow. */
 228             fail = 1;
 229             f = NULL;
 230         } else {
 231             f = fopen_recursive(buf, "wb");
 232         }
 233 #else
 234         snprintf(buf, sizeof(buf), "~/somewhere/%s/%s", req_info->remote_user, req_info->local_uri);
 235         buf[sizeof(buf)-1] = 0;
 236         if (strlen(buf)>1020) {
 237             /* The string is too long and probably truncated. Make sure an
 238              * UTF-8 string is never truncated between the UTF-8 code bytes.
 239              * This example code must be adapted to the specific needs. */
 240             fail = 1;
 241             f = NULL;
 242         } else {
 243             f = fopen_recursive(buf, "w");
 244         }
 245 #endif
 246
 247         if (!f) {
 248             fail = 1;
 249         } else {
 250             while (nlen < tlen) {
 251                 rlen = tlen - nlen;
 252                 if (rlen > sizeof(buf)) {
 253                     rlen = sizeof(buf);
 254                 }
 255                 rlen = mg_read(conn, buf, (size_t)rlen);
 256                 if (rlen <= 0) {
 257                     fail = 1;
 258                     break;
 259                 }
 260                 wlen = fwrite(buf, 1, (size_t)rlen, f);
 261                 if (wlen != rlen) {
 262                     fail = 1;
 263                     break;
 264                 }
 265                 nlen += wlen;
 266             }
 267             fclose(f);
 268         }
 269
 270         if (fail) {
 271             mg_printf(conn,
 272                 "HTTP/1.1 409 Conflict\r\n"
 273                 "Content-Type: text/plain\r\n"
 274                 "Connection: close\r\n\r\n");
 275         } else {
 276             mg_printf(conn,
 277                 "HTTP/1.1 201 Created\r\n"
 278                 "Content-Type: text/plain\r\n"
 279                 "Connection: close\r\n\r\n");
 280         }
 281
 282         return true;
 283     }
 284 };
 285
 286 class WsStartHandler : public CivetHandler
 287 {
 288   public:
 289         bool
 290         handleGet(CivetServer *server, struct mg_connection *conn)
 291         {
 292
 293         mg_printf(conn,
 294                   "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: "
 295                   "close\r\n\r\n");
 296
 297         mg_printf(conn, "<!DOCTYPE html>\n");
 298         mg_printf(conn, "<html>\n<head>\n");
 299         mg_printf(conn, "<meta charset=\"UTF-8\">\n");
 300         mg_printf(conn, "<title>Embedded websocket example</title>\n");
 301
 302 #ifdef USE_WEBSOCKET
 303         /* mg_printf(conn, "<script type=\"text/javascript\"><![CDATA[\n"); ...
 304          * xhtml style */
 305         mg_printf(conn, "<script>\n");
 306         mg_printf(
 307             conn,
 308             "var i=0\n"
 309             "function load() {\n"
 310             "  var wsproto = (location.protocol === 'https:') ? 'wss:' : 'ws:';\n"
 311             "  connection = new WebSocket(wsproto + '//' + window.location.host + "
 312             "'/websocket');\n"
 313             "  websock_text_field = "
 314             "document.getElementById('websock_text_field');\n"
 315             "  connection.onmessage = function (e) {\n"
 316             "    websock_text_field.innerHTML=e.data;\n"
 317             "    i=i+1;"
 318             "    connection.send(i);\n"
 319             "  }\n"
 320             "  connection.onerror = function (error) {\n"
 321             "    alert('WebSocket error');\n"
 322             "    connection.close();\n"
 323             "  }\n"
 324             "}\n");
 325         /* mg_printf(conn, "]]></script>\n"); ... xhtml style */
 326         mg_printf(conn, "</script>\n");
 327         mg_printf(conn, "</head>\n<body onload=\"load()\">\n");
 328         mg_printf(
 329             conn,
 330             "<div id='websock_text_field'>No websocket connection yet</div>\n");
 331 #else
 332         mg_printf(conn, "</head>\n<body>\n");
 333         mg_printf(conn, "Example not compiled with USE_WEBSOCKET\n");
 334 #endif
 335         mg_printf(conn, "</body>\n</html>\n");
 336
 337         return 1;
 338 }
 339 };
 340
 341
 342 #ifdef USE_WEBSOCKET
 343 class WebSocketHandler : public CivetWebSocketHandler {
 344
 345         virtual bool handleConnection(CivetServer *server,
 346                                       const struct mg_connection *conn) {
 347                 printf("WS connected\n");
 348                 return true;
 349         }
 350
 351         virtual void handleReadyState(CivetServer *server,
 352                                       struct mg_connection *conn) {
 353                 printf("WS ready\n");
 354
 355                 const char *text = "Hello from the websocket ready handler";
 356                 mg_websocket_write(conn, MG_WEBSOCKET_OPCODE_TEXT, text, strlen(text));
 357         }
 358
 359         virtual bool handleData(CivetServer *server,
 360                                 struct mg_connection *conn,
 361                                 int bits,
 362                                 char *data,
 363                                 size_t data_len) {
 364                 printf("WS got %lu bytes: ", (long unsigned)data_len);
 365                 fwrite(data, 1, data_len, stdout);
 366                 printf("\n");
 367
 368                 mg_websocket_write(conn, MG_WEBSOCKET_OPCODE_TEXT, data, data_len);
 369                 return (data_len<4);
 370         }
 371
 372         virtual void handleClose(CivetServer *server,
 373                                  const struct mg_connection *conn) {
 374                 printf("WS closed\n");
 375         }
 376 };
 377 #endif
 378
 379
 380 int
 381 main(int argc, char *argv[])
 382 {
 383         mg_init_library(0);
 384
 385         const char *options[] = {
 386             "document_root", DOCUMENT_ROOT, "listening_ports", PORT, 0};
 387
 388     std::vector<std::string> cpp_options;
 389     for (int i=0; i<(sizeof(options)/sizeof(options[0])-1); i++) {
 390         cpp_options.push_back(options[i]);
 391     }
 392
 393         // CivetServer server(options); // <-- C style start
 394         CivetServer server(cpp_options); // <-- C++ style start
 395
 396         ExampleHandler h_ex;
 397         server.addHandler(EXAMPLE_URI, h_ex);
 398
 399         ExitHandler h_exit;
 400         server.addHandler(EXIT_URI, h_exit);
 401
 402         AHandler h_a;
 403         server.addHandler("/a", h_a);
 404
 405         ABHandler h_ab;
 406         server.addHandler("/a/b", h_ab);
 407
 408         WsStartHandler h_ws;
 409         server.addHandler("/ws", h_ws);
 410
 411 #ifdef NO_FILES
 412         /* This handler will handle "everything else", including
 413          * requests to files. If this handler is installed,
 414          * NO_FILES should be set. */
 415         FooHandler h_foo;
 416         server.addHandler("", h_foo);
 417
 418         printf("See a page from the \"all\" handler at http://localhost:%s/\n", PORT);
 419 #else
 420         FooHandler h_foo;
 421         server.addHandler("**.foo", h_foo);
 422         printf("Browse files at http://localhost:%s/\n", PORT);
 423 #endif
 424
 425 #ifdef USE_WEBSOCKET
 426         WebSocketHandler h_websocket;
 427         server.addWebSocketHandler("/websocket", h_websocket);
 428         printf("Run websocket example at http://localhost:%s/ws\n", PORT);
 429 #endif
 430
 431         printf("Run example at http://localhost:%s%s\n", PORT, EXAMPLE_URI);
 432         printf("Exit at http://localhost:%s%s\n", PORT, EXIT_URI);
 433
 434         while (!exitNow) {
 435 #ifdef _WIN32
 436                 Sleep(1000);
 437 #else
 438                 sleep(1);
 439 #endif
 440         }
 441
 442         printf("Bye!\n");
 443         mg_exit_library();
 444
 445         return 0;
 446 }