/*
- * Copyright (C) 2016 "IoT.bzh"
+ * Copyright (C) 2015-2020 "IoT.bzh"
* Author: José Bollo <jose.bollo@iot.bzh>
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include <sys/uio.h>
#include <string.h>
#include <stdarg.h>
-
-#include <systemd/sd-event.h>
+#include <poll.h>
#include "websock.h"
#include "afb-ws.h"
-
-#include "afb-common.h"
+#include "fdev.h"
/*
* declaration of the websock interface for afb-ws
const struct afb_ws_itf *itf; /* the callback interface */
void *closure; /* closure when calling the callbacks */
struct websock *ws; /* the websock handler */
- sd_event_source *evsrc; /* the event source for the socket */
+ struct fdev *fdev; /* the fdev for the socket */
struct buf buffer; /* the last read fragment */
};
static inline struct buf aws_pick_buffer(struct afb_ws *ws)
{
struct buf result = ws->buffer;
+ if (result.buffer)
+ result.buffer[result.size] = 0;
ws->buffer.buffer = NULL;
ws->buffer.size = 0;
return result;
}
+/*
+ * Clear the current buffer
+ */
+static inline void aws_clear_buffer(struct afb_ws *ws)
+{
+ ws->buffer.size = 0;
+}
+
/*
* Disconnect the websocket 'ws' and calls on_hangup if
* 'call_on_hangup' is not null.
struct websock *wsi = ws->ws;
if (wsi != NULL) {
ws->ws = NULL;
- sd_event_source_unref(ws->evsrc);
- ws->evsrc = NULL;
+ fdev_set_callback(ws->fdev, NULL, 0);
+ fdev_unref(ws->fdev);
websock_destroy(wsi);
- free(aws_pick_buffer(ws).buffer);
+ free(ws->buffer.buffer);
ws->state = waiting;
if (call_on_hangup && ws->itf->on_hangup)
ws->itf->on_hangup(ws->closure);
}
}
-static int io_event_callback(sd_event_source *src, int fd, uint32_t revents, void *ws)
+static void fdevcb(void *ws, uint32_t revents, struct fdev *fdev)
{
- if ((revents & EPOLLIN) != 0)
- aws_on_readable(ws);
if ((revents & EPOLLHUP) != 0)
afb_ws_hangup(ws);
- return 0;
+ else if ((revents & EPOLLIN) != 0)
+ aws_on_readable(ws);
}
/*
*
* Returns the handle for the afb_ws created or NULL on error.
*/
-struct afb_ws *afb_ws_create(struct sd_event *eloop, int fd, const struct afb_ws_itf *itf, void *closure)
+struct afb_ws *afb_ws_create(struct fdev *fdev, const struct afb_ws_itf *itf, void *closure)
{
- int rc;
struct afb_ws *result;
- assert(fd >= 0);
+ assert(fdev);
/* allocation */
result = malloc(sizeof * result);
goto error;
/* init */
- result->fd = fd;
+ result->fdev = fdev;
+ result->fd = fdev_fd(fdev);
result->state = waiting;
result->itf = itf;
result->closure = closure;
if (result->ws == NULL)
goto error2;
- /* creates the evsrc */
- rc = sd_event_add_io(eloop, &result->evsrc, result->fd, EPOLLIN, io_event_callback, result);
- if (rc < 0) {
- errno = -rc;
- goto error3;
- }
+ /* finalize */
+ fdev_set_events(fdev, EPOLLIN);
+ fdev_set_callback(fdev, fdevcb, result);
return result;
-error3:
- websock_destroy(result->ws);
error2:
free(result);
error:
+ fdev_unref(fdev);
return NULL;
}
*/
static ssize_t aws_writev(struct afb_ws *ws, const struct iovec *iov, int iovcnt)
{
- ssize_t rc;
- do {
- rc = writev(ws->fd, iov, iovcnt);
- } while(rc == -1 && errno == EINTR);
- return rc;
+ int i;
+ ssize_t rc, sz, dsz;
+ struct iovec *iov2;
+ struct pollfd pfd;
+
+ /* compute the size */
+ dsz = 0;
+ i = 0;
+ while (i < iovcnt) {
+ dsz += iov[i++].iov_len;
+ if (dsz < 0) {
+ errno = EINVAL;
+ return -1;
+ }
+ }
+ if (dsz == 0)
+ return 0;
+
+ /* write the data */
+ iov2 = (struct iovec*)iov;
+ sz = dsz;
+ for (;;) {
+ rc = writev(ws->fd, iov2, iovcnt);
+ if (rc < 0) {
+ if (errno == EINTR)
+ continue;
+ if (errno != EAGAIN)
+ return -1;
+ } else {
+ dsz -= rc;
+ if (dsz == 0)
+ return sz;
+
+ i = 0;
+ while (rc >= (ssize_t)iov2[i].iov_len)
+ rc -= (ssize_t)iov2[i++].iov_len;
+
+ iovcnt -= i;
+ if (iov2 != iov)
+ iov2 += i;
+ else {
+ iov += i;
+ iov2 = alloca(iovcnt * sizeof *iov2);
+ for (i = 0 ; i < iovcnt ; i++)
+ iov2[i] = iov[i];
+ }
+ iov2->iov_base += rc;
+ iov2->iov_len -= rc;
+ }
+ pfd.fd = ws->fd;
+ pfd.events = POLLOUT;
+ poll(&pfd, 1, 10);
+ }
}
/*
int rc;
assert(ws->ws != NULL);
- rc = websock_dispatch(ws->ws);
+ rc = websock_dispatch(ws->ws, 0);
if (rc < 0 && errno == EPIPE)
afb_ws_hangup(ws);
}
*/
static int aws_read(struct afb_ws *ws, size_t size)
{
+ struct pollfd pfd;
ssize_t sz;
char *buffer;
- if (size != 0) {
+ if (size != 0 || ws->buffer.buffer == NULL) {
buffer = realloc(ws->buffer.buffer, ws->buffer.size + size + 1);
if (buffer == NULL)
return 0;
ws->buffer.buffer = buffer;
- sz = websock_read(ws->ws, &buffer[ws->buffer.size], size);
- if ((size_t)sz != size)
- return 0;
- ws->buffer.size += size;
+ while (size != 0) {
+ sz = websock_read(ws->ws, &buffer[ws->buffer.size], size);
+ if (sz < 0) {
+ if (errno != EAGAIN)
+ return 0;
+ pfd.fd = ws->fd;
+ pfd.events = POLLIN;
+ poll(&pfd, 1, 10); /* TODO: make fully asynchronous websockets */
+ } else {
+ ws->buffer.size += (size_t)sz;
+ size -= (size_t)sz;
+ }
+ }
}
return 1;
}
struct buf b;
ws->state = waiting;
- free(aws_pick_buffer(ws).buffer);
+ aws_clear_buffer(ws);
if (ws->itf->on_close == NULL) {
websock_drop(ws->ws);
afb_ws_hangup(ws);
static void aws_drop_error(struct afb_ws *ws, uint16_t code)
{
ws->state = waiting;
- free(aws_pick_buffer(ws).buffer);
+ aws_clear_buffer(ws);
websock_drop(ws->ws);
websock_error(ws->ws, code, NULL, 0);
}
istxt = ws->state == reading_text;
ws->state = waiting;
b = aws_pick_buffer(ws);
- b.buffer[b.size] = 0;
(istxt ? ws->itf->on_text : ws->itf->on_binary)(ws->closure, b.buffer, b.size);
}
}
}
/*
- * Callback when 'close' command received from 'ws' with 'code' and 'size'.
+ * Callback when 'continue' command received from 'ws' with 'code' and 'size'.
*/
static void aws_on_continue(struct afb_ws *ws, int last, size_t size)
{
Code Review / src / app-framework-binder.git / blobdiff