how do you do low-level "write(const char* msg, int len)" like in v0.14?

[jvo203]

I am trying to port the code from v0.14 to v0.16. Back in v.014 there is a lot of freedom for the user to do low-level writes like

res->write("\r\n\r\n", 4);

or
// chunk header
std::ostringstream chunk;
chunk << std::hex << have << "\r\n";
stream.res->write(chunk.str().c_str(), chunk.tellp());

// chunk contents
stream.res->write((const char *)stream.out, have);
stream.res->write("\r\n", 2);

The new version v0.16 does not seem to allow one to do write(const char* msg, int len), there is only write(std::string_view data). Trying to do call Super::write(const char* msg, int len) from a user code results in errors like "error: ‘Super’ has not been declared" or Super::write is protected etc. Is there not an easy way to do low-level things anymore? I have a lot of custom low-level functions that need to be upgraded to v0.16, i.e.

void write_content_length(uWS::HttpResponse *res, size_t length) {
std::string content_length =
"Content-Length: " + std::to_string(length) + "\r\n";
res->write(content_length.data(), content_length.length());
}

Simply replacing "uWS::HttpResponse *res" with "auto *res" is not sufficient. The API seems to have changed quite a lot.

[ghost]

If you want to stream in chunks you just call write and it will automatically go into chunking mode. It works exactly like Node.js.

[jvo203]

Hi Alex, so you mean there is no need to do "write_key_value(stream->res, "Transfer-Encoding", "chunked");", and then write out the chunk length plus "stream->res->write("\r\n", 2);" as a chunk separator? One can just write the chunk body with write(std::string_view data)? And the last chunk should be sent with the function "end(std::string_view data = {})", is that right?

What about using the old function (now Super::)write(const char* msg, int len)? It does not seem possible to use it anymore. One can only use write(std::string_view).

In the new v0.16 version, do html responses always need to be ended with a command "end()" instead of a manual "res->write("\r\n\r\n", 4);"? With the old but stable v0.14 I used to send data manually the following way, including adding the content length, the OK status etc:

write_status(res, 200, "OK");
write_content_length(res, html.length());
write_content_type(res, "text/html");
res->write("\r\n", 2);
res->write(html.data(), html.length());
res->write("\r\n\r\n", 4);

[ghost]

If you take a look at the TypeScript docs over at uWebSockets.js you can see the new helper functions. You don't need to do this manullay, there are helpers for this now.

[jvo203]

Thank you, indeed there are helper functions for writing the header, status etc.

The upgrade to v0.16 (a multithreaded HTTP+WS server) ended abruptly with the following error:
Error: Returning from a request handler without responding or attaching an abort handler is forbidden!
terminate called without an active exception

Only the first HTTP request (a file) gets served properly. Upon serving subsequent files the program crashes with a segmentation fault. The code used to work perfectly well with v0.14. The serve_file function is per the following. Could it be that the std::string_view body simply does not live long enough, does v0.16 not copy data in the end(std::string_view) function?

void serve_file(auto *res, std::string uri) {
std::string resource = "htdocs" + uri;

// strip '?' from the requested file name
size_t pos = resource.find("?");

if (pos != std::string::npos)
resource = resource.substr(0, pos);

std::cout << "serving " << resource << std::endl;

// mmap a disk resource
int fd = -1;
void *buffer = NULL;

struct stat64 st;
stat64(resource.c_str(), &st);
long size = st.st_size;

fd = open(resource.c_str(), O_RDONLY);

if (fd != -1) {
buffer = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);

if (buffer != NULL) {
  // detect mime-types
  size_t pos = resource.find_last_of(".");

  if (pos != std::string::npos) {
    std::string ext = resource.substr(pos + 1, std::string::npos);

    if (ext == "htm" || ext == "html")
      res->writeHeader("Content-Type", "text/html");

    if (ext == "txt")
      res->writeHeader("Content-Type", "text/plain");

    if (ext == "js")
      res->writeHeader("Content-Type", "application/javascript");

    if (ext == "ico")
      res->writeHeader("Content-Type", "image/x-icon");

    if (ext == "png")
      res->writeHeader("Content-Type", "image/png");

    if (ext == "gif")
      res->writeHeader("Content-Type", "image/gif");

    if (ext == "webp")
      res->writeHeader("Content-Type", "image/webp");

    if (ext == "jpg" || ext == "jpeg")
      res->writeHeader("Content-Type", "image/jpeg");

    if (ext == "bpg")
      res->writeHeader("Content-Type", "image/bpg");

    if (ext == "mp4")
      res->writeHeader("Content-Type", "video/mp4");

    if (ext == "hevc")
      res->writeHeader("Content-Type", "video/hevc");

    if (ext == "css")
      res->writeHeader("Content-Type", "text/css");

    if (ext == "pdf")
      res->writeHeader("Content-Type", "application/pdf");

    if (ext == "svg")
      res->writeHeader("Content-Type", "image/svg+xml");

    if (ext == "wasm")
      res->writeHeader("Content-Type", "application/wasm");
  }

  std::string_view body((const char *)buffer, size);
  res->end(body);
} else {
  perror("error mapping a file");
  http_not_found(res);
}

if (munmap(buffer, size) == -1)
  perror("un-mapping error");

close(fd);

} else
http_not_found(res);
}

[jvo203]

OK. Am closing this issue. The reason for the above error message had to do with not handling responses for all possible cases. After adding a default handler for the remaining request conditions the code does not crash anymore.