int inline ws_send(struct tcp_connection *con, int fd, int op,
char *body, unsigned int len)
{
/*
* we need this buffer to mask the message sent to the client
* since we cannot modify the buffer - it might be readonly
*/
static char *body_buf = 0;
static unsigned char hdr_buf[WS_MAX_HDR_LEN];
static struct iovec v[2] = { {hdr_buf, 0}, {0, 0}};
unsigned int mask = rand();
/* FIN + OPCODE */
hdr_buf[0] = WS_BIT_FIN | (op & WS_MASK_OPCODE);
if (len == 0) {
hdr_buf[1] = 0;
/* don't have any data, send only the heeader */
return ws_raw_write(con, fd, (char *)hdr_buf, WS_MIN_HDR_LEN);
} else if (len < WS_EXT_LEN) {
hdr_buf[1] = len;
v[0].iov_len = WS_MIN_HDR_LEN;
} else if (len < WS_MAX_ELEN) {
v[0].iov_len = WS_MIN_HDR_LEN + WS_ELEN_SIZE;
hdr_buf[1] = WS_EXT_LEN;
*(uint16_t *)(hdr_buf + WS_MIN_HDR_LEN) = htons(len);
} else {
v[0].iov_len = WS_MIN_HDR_LEN + WS_ELENC_SIZE;
hdr_buf[1] = WS_EXTC_LEN;
/* len can't be larger than 32 bits long */
*(uint64_t *)(hdr_buf + WS_MIN_HDR_LEN) = htonl(len);
}
if (WS_TYPE(con) == WS_CLIENT) {
/* set the mask in the message */
*(uint32_t *)(v[0].iov_base + v[0].iov_len) = mask;
v[0].iov_len += WS_MASK_SIZE;
/* also indicate that the message is masked */
hdr_buf[1] |= WS_BIT_MASK;
body_buf = body_buf ? pkg_realloc(body_buf, len) : pkg_malloc(len);
if (!body_buf) {
LM_ERR("oom for body buffer\n");
return -1;
}
memcpy(body_buf, body, len);
ws_mask(body_buf, len, mask);
v[1].iov_base = body_buf;
} else {
v[1].iov_base = body;
}
v[1].iov_len = len;
return ws_raw_writev(con, fd, v, 2);
}
static struct tcp_connection* ws_connect(struct socket_info* send_sock,
union sockaddr_union* to, int *fd)
{
struct tcp_connection *c;
if ((c=ws_sync_connect(send_sock, to))==0) {
LM_ERR("connect failed\n");
return NULL;
}
/* the state of the connection should be NONE, otherwise something is
* wrong */
if (WS_TYPE(c) != WS_NONE) {
LM_BUG("invalid type for connection %d\n", WS_TYPE(c));
goto error;
}
WS_TYPE(c) = WS_CLIENT;
if (ws_client_handshake(c) < 0) {
LM_ERR("cannot complete WebSocket handshake\n");
goto error;
}
*fd = c->fd;
/* clear the fd, just in case */
c->fd = -1;
/* handshake done - send the socket to main */
if (tcp_conn_send(c) < 0) {
LM_ERR("cannot send socket to main\n");
goto error;
}
return c;
error:
tcp_conn_destroy(c);
return NULL;
}
int ws_process(struct tcp_connection *con)
{
struct ws_req *req;
struct ws_req *newreq;
long size = 0;
enum ws_close_code ret_code = WS_ERR_NONE;
unsigned char bk;
char *msg_buf;
int msg_len;
struct receive_info local_rcv;
if (con->con_req) {
req=(struct ws_req *)con->con_req;
LM_DBG("Using the per connection buff \n");
} else {
LM_DBG("Using the global ( per process ) buff \n");
init_ws_req(&ws_current_req, 0);
req=&ws_current_req;
}
again:
if (req->tcp.error == TCP_REQ_OK) {
if (req->tcp.parsed >= req->tcp.pos) {
if (ws_raw_read(con, &req->tcp) < 0) {
LM_ERR("failed to read %d:%s\n", errno, strerror(errno));
goto error;
}
}
ret_code = ws_parse(req);
if (ret_code)
goto error;
/* eof check:
* is EOF if eof on fd and r. not complete yet,
* if r. is complete we might have a second unparsed
* request after it, so postpone release_with_eof
*/
if ((con->state==S_CONN_EOF) && (req->tcp.complete==0)) {
LM_DBG("EOF received\n");
goto done;
}
/* sanity mask checks */
if ((WS_TYPE(con) == WS_CLIENT && req->is_masked) ||
(WS_TYPE(con) == WS_SERVER && !req->is_masked)) {
LM_DBG("malformed WS msg - %s %s\n",
req->is_masked ? "masked" : "not masked",
WS_TYPE(con) == WS_CLIENT ? "client" : "server");
ret_code = WS_ERR_BADDATA;
goto error;
}
}
if (req->tcp.complete) {
/* update the timeout - we succesfully read the request */
tcp_conn_set_lifetime(con, ws_send_timeout);
con->timeout=con->lifetime;
/* if we are here everything is nice and ok*/
update_stat( pt[process_no].load, +1 );
/* rcv.bind_address should always be !=0 */
bind_address=con->rcv.bind_address;
con->rcv.proto_reserved1=con->id; /* copy the id */
size=req->tcp.pos-req->tcp.parsed;
switch (req->op) {
case WS_OP_CLOSE:
if (req->tcp.content_len) {
/* for now we are only interested in the code, not the reason */
ret_code = WS_CLOSE_CODE(req);
switch(ret_code) {
case WS_ERR_NORMAL: LM_DBG("Normal WebSocket close\n"); break;
case WS_ERR_CLIENT: LM_DBG("Client error close\n"); break;
case WS_ERR_PROTO: LM_DBG("WebSocket protocol error\n"); break;
case WS_ERR_BADDATA: LM_DBG("Data type not consistent\n"); break;
case WS_ERR_POLICY: LM_DBG("Bad policy close\n"); break;
case WS_ERR_TOO_BIG: LM_DBG("Packet too big close\n"); break;
case WS_ERR_BADEXT: LM_DBG("Bad extension close\n"); break;
case WS_ERR_UNEXPECT: LM_DBG("Unexpected condition close\n"); break;
default:
LM_DBG("Unknown WebSocket close: %d\n", ret_code);
}
} else {
ret_code = WS_ERR_NORMAL;
}
/* respond to close */
WS_CODE(con) = ret_code;
ws_send_close(con);
WS_CODE(con) = WS_ERR_NOSEND;
/* release the connextion */
con->state = S_CONN_EOF;
goto done;
case WS_OP_PING:
if (ws_send_pong(con, req) < 0)
LM_ERR("cannot send PONG msg\n");
break;
case WS_OP_PONG:
LM_DBG("Received WebSocket PONG\n");
break;
case WS_OP_TEXT:
case WS_OP_BIN:
bk = *req->tcp.parsed;
*req->tcp.parsed = 0;
msg_buf = req->tcp.body;
msg_len = req->tcp.parsed-req->tcp.body;
local_rcv = con->rcv;
if (!size) {
/* did not read any more things - we can release
* the connection */
LM_DBG("We're releasing the connection in state %d \n",
con->state);
if (req != &ws_current_req) {
/* we have the buffer in the connection tied buff -
* detach it , release the conn and free it afterwards */
con->con_req = NULL;
}
/* TODO - we could indicate to the TCP net layer to release
* the connection -> other worker may read the next available
* message on the pipe */
} else {
LM_DBG("We still have things on the pipe - "
"keeping connection \n");
}
if (receive_msg(msg_buf, msg_len, &local_rcv) <0)
LM_ERR("receive_msg failed \n");
*req->tcp.parsed = bk;
break;
default:
LM_BUG("Can't handle %d\n", req->op);
goto error;
}
update_stat( pt[process_no].load, -1 );
if (size) memmove(req->tcp.buf, req->tcp.parsed, size);
#ifdef EXTRA_DEBUG
LM_DBG("preparing for new request, kept %ld bytes\n", size);
#endif
init_ws_req(req, size);
con->msg_attempts = 0;
/* if we still have some unparsed bytes, try to parse them too*/
if (size)
goto again;
/* cleanup the existing request */
if (req != &ws_current_req)
pkg_free(req);
} else {
/* request not complete - check the if the thresholds are exceeded */
con->msg_attempts++;
if (con->msg_attempts == ws_max_msg_chunks) {
LM_ERR("Made %u read attempts but message is not complete yet - "
"closing connection \n",con->msg_attempts);
goto error;
}
if (req == &ws_current_req) {
/* let's duplicate this - most likely another conn will come in */
LM_DBG("We didn't manage to read a full request\n");
newreq = pkg_malloc(sizeof(struct ws_req));
if (newreq == NULL) {
LM_ERR("No more mem for dynamic con request buffer\n");
goto error;
}
if (req->tcp.pos != req->tcp.buf) {
/* we have read some bytes */
memcpy(newreq->tcp.buf,req->tcp.buf,req->tcp.pos-req->tcp.buf);
newreq->tcp.pos = newreq->tcp.buf + (req->tcp.pos-req->tcp.buf);
} else {
newreq->tcp.pos = newreq->tcp.buf;
}
if (req->tcp.start != req->tcp.buf)
newreq->tcp.start = newreq->tcp.buf +(req->tcp.start-req->tcp.buf);
else
newreq->tcp.start = newreq->tcp.buf;
if (req->tcp.parsed != req->tcp.buf)
newreq->tcp.parsed =newreq->tcp.buf+(req->tcp.parsed-req->tcp.buf);
else
newreq->tcp.parsed = newreq->tcp.buf;
if (req->tcp.body != 0) {
newreq->tcp.body = newreq->tcp.buf + (req->tcp.body-req->tcp.buf);
} else
newreq->tcp.body = 0;
newreq->tcp.complete=req->tcp.complete;
newreq->tcp.has_content_len=req->tcp.has_content_len;
newreq->tcp.content_len=req->tcp.content_len;
newreq->tcp.bytes_to_go=req->tcp.bytes_to_go;
newreq->tcp.error = req->tcp.error;
newreq->tcp.state = req->tcp.state;
newreq->op = req->op;
newreq->mask = req->mask;
newreq->is_masked = req->is_masked;
con->con_req = (struct tcp_req *)newreq;
}
}
LM_DBG("ws_read end\n");
done:
/* connection will be released */
return size;
error:
WS_CODE(con) = ret_code;
if (WS_CODE(con) != WS_ERR_NONE) {
ws_send_close(con);
WS_CODE(con) = WS_ERR_NOSEND;
}
return -1;
}
