static int callback_raw_test(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) { struct per_session_data__raw_test *pss = (struct per_session_data__raw_test *)user; struct per_vhost_data__raw_test *vhd = (struct per_vhost_data__raw_test *) lws_protocol_vh_priv_get(lws_get_vhost(wsi), lws_get_protocol(wsi)); lws_sock_file_fd_type u; (void)pss; switch (reason) { case LWS_CALLBACK_PROTOCOL_INIT: vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi), lws_get_protocol(wsi), sizeof(struct per_vhost_data__raw_test)); vhd->context = lws_get_context(wsi); vhd->protocol = lws_get_protocol(wsi); vhd->vhost = lws_get_vhost(wsi); { const struct lws_protocol_vhost_options *pvo = (const struct lws_protocol_vhost_options *)in; while (pvo) { if (!strcmp(pvo->name, "fifo-path")) lws_strncpy(vhd->fifo_path, pvo->value, sizeof(vhd->fifo_path)); pvo = pvo->next; } if (vhd->fifo_path[0] == '\0') { lwsl_err("%s: Missing pvo \"fifo-path\", raw file fd testing disabled\n", __func__); break; } } unlink(vhd->fifo_path); if (mkfifo(vhd->fifo_path, 0666)) { lwsl_err("mkfifo failed\n"); return 1; } vhd->fifo = lws_open(vhd->fifo_path, O_NONBLOCK | O_RDONLY); if (vhd->fifo == -1) { lwsl_err("opening fifo failed\n"); unlink(vhd->fifo_path); return 1; } lwsl_notice("FIFO %s created\n", vhd->fifo_path); u.filefd = vhd->fifo; if (!lws_adopt_descriptor_vhost(vhd->vhost, LWS_ADOPT_RAW_FILE_DESC, u, "protocol-lws-raw-test", NULL)) { lwsl_err("Failed to adopt fifo descriptor\n"); close(vhd->fifo); unlink(vhd->fifo_path); return 1; } break; case LWS_CALLBACK_PROTOCOL_DESTROY: if (!vhd) break; if (vhd->fifo >= 0) { close(vhd->fifo); unlink(vhd->fifo_path); } break; /* * Callbacks related to Raw file descriptor testing */ case LWS_CALLBACK_RAW_ADOPT_FILE: lwsl_notice("LWS_CALLBACK_RAW_ADOPT_FILE\n"); break; case LWS_CALLBACK_RAW_RX_FILE: lwsl_notice("LWS_CALLBACK_RAW_RX_FILE\n"); { char buf[256]; int n; n = read(vhd->fifo, buf, sizeof(buf) - 1); if (n < 0) { lwsl_err("FIFO read failed\n"); return 1; } /* * When nobody opened the other side of the FIFO, the FIFO fd acts well and * only signals POLLIN when somebody opened and wrote to it. * * But if the other side of the FIFO closed it, we will see an endless * POLLIN and 0 available to read. * * The only way to handle it is to reopen the FIFO our side and wait for a * new peer. This is a quirk of FIFOs not of LWS. */ if (n == 0) { /* peer closed - do reopen in close processing */ vhd->zero_length_read = 1; return 1; } buf[n] = '\0'; lwsl_info("read %d\n", n); puts(buf); } break; case LWS_CALLBACK_RAW_CLOSE_FILE: lwsl_notice("LWS_CALLBACK_RAW_CLOSE_FILE\n"); if (vhd->zero_length_read) { vhd->zero_length_read = 0; close(vhd->fifo); /* the wsi that adopted the fifo file is closing... reopen the fifo and readopt */ vhd->fifo = lws_open(vhd->fifo_path, O_NONBLOCK | O_RDONLY); if (vhd->fifo == -1) { lwsl_err("opening fifo failed\n"); return 1; } lwsl_notice("FIFO %s reopened\n", vhd->fifo_path); u.filefd = vhd->fifo; if (!lws_adopt_descriptor_vhost(vhd->vhost, 0, u, "protocol-lws-raw-test", NULL)) { lwsl_err("Failed to adopt fifo descriptor\n"); close(vhd->fifo); return 1; } } break; case LWS_CALLBACK_RAW_WRITEABLE_FILE: lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE_FILE\n"); break; /* * Callbacks related to Raw socket descriptor testing */ case LWS_CALLBACK_RAW_ADOPT: lwsl_notice("LWS_CALLBACK_RAW_ADOPT\n"); break; case LWS_CALLBACK_RAW_RX: lwsl_notice("LWS_CALLBACK_RAW_RX %ld\n", (long)len); if (len > sizeof(pss->buf)) len = sizeof(pss->buf); memcpy(pss->buf, in, len); pss->len = len; lws_callback_on_writable(wsi); break; case LWS_CALLBACK_RAW_CLOSE: lwsl_notice("LWS_CALLBACK_RAW_CLOSE\n"); break; case LWS_CALLBACK_RAW_WRITEABLE: lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE\n"); lws_write(wsi, pss->buf, pss->len, LWS_WRITE_HTTP); break; default: break; } return 0; }
static int callback_raw_test(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) { struct raw_vhd *vhd = (struct raw_vhd *)lws_protocol_vh_priv_get( lws_get_vhost(wsi), lws_get_protocol(wsi)); lws_sock_file_fd_type u; uint8_t buf[1024]; int n; switch (reason) { case LWS_CALLBACK_PROTOCOL_INIT: vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi), lws_get_protocol(wsi), sizeof(struct raw_vhd)); vhd->filefd = lws_open(filepath, O_RDWR); if (vhd->filefd == -1) { lwsl_err("Unable to open %s\n", filepath); return 1; } u.filefd = (lws_filefd_type)(long long)vhd->filefd; if (!lws_adopt_descriptor_vhost(lws_get_vhost(wsi), LWS_ADOPT_RAW_FILE_DESC, u, "raw-test", NULL)) { lwsl_err("Failed to adopt fifo descriptor\n"); close(vhd->filefd); vhd->filefd = -1; return 1; } break; case LWS_CALLBACK_PROTOCOL_DESTROY: if (vhd && vhd->filefd != -1) close(vhd->filefd); break; /* callbacks related to raw file descriptor */ case LWS_CALLBACK_RAW_ADOPT_FILE: lwsl_notice("LWS_CALLBACK_RAW_ADOPT_FILE\n"); break; case LWS_CALLBACK_RAW_RX_FILE: lwsl_notice("LWS_CALLBACK_RAW_RX_FILE\n"); n = read(vhd->filefd, buf, sizeof(buf)); if (n < 0) { lwsl_err("Reading from %s failed\n", filepath); return 1; } lwsl_hexdump_level(LLL_NOTICE, buf, n); break; case LWS_CALLBACK_RAW_CLOSE_FILE: lwsl_notice("LWS_CALLBACK_RAW_CLOSE_FILE\n"); break; case LWS_CALLBACK_RAW_WRITEABLE_FILE: lwsl_notice("LWS_CALLBACK_RAW_WRITEABLE_FILE\n"); /* * you can call lws_callback_on_writable() on a raw file wsi as * usual, and then write directly into the raw filefd here. */ break; default: break; } return 0; }