libwebsockets/lib/core-net/output.c

/*
 * libwebsockets - small server side websockets and web server implementation
 *
 * Copyright (C) 2010 - 2019 Andy Green <andy@warmcat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include "private-lib-core.h"

/*
 * notice this returns number of bytes consumed, or -1
 */
int
lws_issue_raw(struct lws *wsi, unsigned char *buf, size_t len)
{
	struct lws_context *context = lws_get_context(wsi);
	size_t real_len = len;
	unsigned int n, m;

	/*
	 * If you're looking to dump data being sent down the tls tunnel, see
	 * lws_ssl_capable_write() in lib/tls/mbedtls/mbedtls-ssl.c or
	 * lib/tls/openssl/openssl-ssl.c.
	 *
	 * There's also a corresponding lws_ssl_capable_read() in those files
	 * where you can enable a dump of decrypted data as soon as it was
	 * read.
	 */

	/* just ignore sends after we cleared the truncation buffer */
	if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE &&
	    !lws_has_buffered_out(wsi)
#if defined(LWS_WITH_HTTP_STREAM_COMPRESSION)
	    && !wsi->http.comp_ctx.may_have_more
#endif
	    )
		return (int)len;

	if (buf && lws_has_buffered_out(wsi)) {
		lwsl_wsi_info(wsi, "** prot: %s, incr buflist_out by %lu",
				   wsi->a.protocol->name, (unsigned long)len);

		/*
		 * already buflist ahead of this, add it on the tail of the
		 * buflist, then ignore it for now and act like we're flushing
		 * the buflist...
		 */

		if (lws_buflist_append_segment(&wsi->buflist_out, buf, len))
			return -1;

		buf = NULL;
		len = 0;
	}

	if (wsi->buflist_out) {
		/* we have to drain the earliest buflist_out stuff first */

		len = lws_buflist_next_segment_len(&wsi->buflist_out, &buf);
		real_len = len;

		lwsl_wsi_debug(wsi, "draining %d", (int)len);
	}

	if (!len || !buf)
		return 0;

	if (!wsi->mux_substream && !lws_socket_is_valid(wsi->desc.sockfd))
		lwsl_wsi_err(wsi, "invalid sock");

	/* limit sending */
	if (wsi->a.protocol->tx_packet_size)
		n = (unsigned int)wsi->a.protocol->tx_packet_size;
	else {
		n = (unsigned int)wsi->a.protocol->rx_buffer_size;
		if (!n)
			n = context->pt_serv_buf_size;
	}
	n += LWS_PRE + 4;
	if (n > len)
		n = (unsigned int)len;

	/* nope, send it on the socket directly */

	if (lws_fi(&wsi->fic, "sendfail"))
		m = (unsigned int)LWS_SSL_CAPABLE_ERROR;
	else
		m = (unsigned int)lws_ssl_capable_write(wsi, buf, n);

	lwsl_wsi_info(wsi, "ssl_capable_write (%d) says %d", n, m);

	/* something got written, it can have been truncated now */
	wsi->could_have_pending = 1;

	switch ((int)m) {
	case LWS_SSL_CAPABLE_ERROR:
		/* we're going to close, let close know sends aren't possible */
		wsi->socket_is_permanently_unusable = 1;
		return -1;
	case LWS_SSL_CAPABLE_MORE_SERVICE:
		/*
		 * nothing got sent, not fatal.  Retry the whole thing later,
		 * ie, implying treat it was a truncated send so it gets
		 * retried
		 */
		m = 0;
		break;
	}

	if ((int)m < 0)
		m = 0;

	/*
	 * we were sending this from buflist_out?  Then not sending everything
	 * is a small matter of advancing ourselves only by the amount we did
	 * send in the buflist.
	 */
	if (lws_has_buffered_out(wsi)) {
		if (m) {
			lwsl_wsi_info(wsi, "partial adv %d (vs %ld)",
					   m, (long)real_len);
			lws_buflist_use_segment(&wsi->buflist_out, m);
		}

		if (!lws_has_buffered_out(wsi)) {
			lwsl_wsi_info(wsi, "buflist_out flushed");

			m = (unsigned int)real_len;
			if (lwsi_state(wsi) == LRS_FLUSHING_BEFORE_CLOSE) {
				lwsl_wsi_info(wsi, "*signalling to close now");
				return -1; /* retry closing now */
			}

			if (wsi->close_when_buffered_out_drained) {
				wsi->close_when_buffered_out_drained = 0;
				return -1;
			}

#if defined(LWS_ROLE_H1) || defined(LWS_ROLE_H2)
#if defined(LWS_WITH_SERVER)
			if (wsi->http.deferred_transaction_completed) {
				lwsl_wsi_notice(wsi, "partial completed, doing "
					    "deferred transaction completed");
				wsi->http.deferred_transaction_completed = 0;
				return lws_http_transaction_completed(wsi) ?
							-1 : (int)real_len;
			}
#endif
#endif
#if defined(LWS_ROLE_WS)
			/* Since buflist_out flushed, we're not inside a frame any more */
			if (wsi->ws)
				wsi->ws->inside_frame = 0;
#endif
		}
		/* always callback on writeable */
		lws_callback_on_writable(wsi);

		return (int)m;
	}

#if defined(LWS_WITH_HTTP_STREAM_COMPRESSION)
	if (wsi->http.comp_ctx.may_have_more)
		lws_callback_on_writable(wsi);
#endif

	if (m == real_len)
		/* what we just sent went out cleanly */
		return (int)m;

	/*
	 * We were not able to send everything... and we were not sending from
	 * an existing buflist_out.  So we are starting a fresh buflist_out, by
	 * buffering the unsent remainder on it.
	 * (it will get first priority next time the socket is writable).
	 */
	lwsl_wsi_debug(wsi, "new partial sent %d from %lu total",
			    m, (unsigned long)real_len);

	if (lws_buflist_append_segment(&wsi->buflist_out, buf + m,
				       real_len - m) < 0)
		return -1;

#if defined(LWS_WITH_UDP)
	if (lws_wsi_is_udp(wsi))
		/* stash original destination for fulfilling UDP partials */
		wsi->udp->sa46_pending = wsi->udp->sa46;
#endif

	/* since something buffered, force it to get another chance to send */
	lws_callback_on_writable(wsi);

	return (int)real_len;
}

int
lws_write(struct lws *wsi, unsigned char *buf, size_t len,
	  enum lws_write_protocol wp)
{
	int m;

	if ((int)len < 0) {
		lwsl_wsi_err(wsi, "suspicious len int %d, ulong %lu",
				  (int)len, (unsigned long)len);
		return -1;
	}

#ifdef LWS_WITH_ACCESS_LOG
	wsi->http.access_log.sent += len;
#endif

	assert(wsi->role_ops);

	if (!lws_rops_fidx(wsi->role_ops, LWS_ROPS_write_role_protocol))
		m = lws_issue_raw(wsi, buf, len);
	else
		m = lws_rops_func_fidx(wsi->role_ops, LWS_ROPS_write_role_protocol).
				write_role_protocol(wsi, buf, len, &wp);

#if defined(LWS_WITH_SYS_METRICS)
	if (wsi->a.vhost)
		lws_metric_event(wsi->a.vhost->mt_traffic_tx, (char)
				 (m < 0 ? METRES_NOGO : METRES_GO), len);
#endif

	return m;
}

int
lws_ssl_capable_read_no_ssl(struct lws *wsi, unsigned char *buf, size_t len)
{
	int n = 0, en;

	errno = 0;
#if defined(LWS_WITH_UDP)
	if (lws_wsi_is_udp(wsi)) {
		socklen_t slt = sizeof(wsi->udp->sa46);

		n = (int)recvfrom(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
				(int)
#endif
				len, 0,
				sa46_sockaddr(&wsi->udp->sa46), &slt);
	} else
#endif
		n = (int)recv(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
				(int)
#endif
				len, 0);
	en = LWS_ERRNO;
	if (n >= 0) {

		if (!n && wsi->unix_skt)
			goto do_err;

		/*
		 * See https://libwebsockets.org/
		 * pipermail/libwebsockets/2019-March/007857.html
		 */
		if (!n && !wsi->unix_skt)
			goto do_err;

#if defined(LWS_WITH_SYS_METRICS) && defined(LWS_WITH_SERVER)
		if (wsi->a.vhost)
			lws_metric_event(wsi->a.vhost->mt_traffic_rx,
					 METRES_GO /* rx */, (unsigned int)n);
#endif

		return n;
	}

	if (en == LWS_EAGAIN ||
	    en == LWS_EWOULDBLOCK ||
	    en == LWS_EINTR)
		return LWS_SSL_CAPABLE_MORE_SERVICE;

do_err:
#if defined(LWS_WITH_SYS_METRICS) && defined(LWS_WITH_SERVER)
	if (wsi->a.vhost)
		lws_metric_event(wsi->a.vhost->mt_traffic_rx, METRES_NOGO, 0u);
#endif

	lwsl_wsi_info(wsi, "error on reading from skt : %d, errno %d", n, en);

	return LWS_SSL_CAPABLE_ERROR;
}

int
lws_ssl_capable_write_no_ssl(struct lws *wsi, unsigned char *buf, size_t len)
{
	int n = 0;
#if defined(LWS_PLAT_OPTEE)
	ssize_t send(int sockfd, const void *buf, size_t len, int flags);
#endif

#if defined(LWS_WITH_UDP)
	if (lws_wsi_is_udp(wsi)) {

		if (lws_fi(&wsi->fic, "udp_tx_loss")) {
			/* pretend it was sent */
			n = (int)(ssize_t)len;
			goto post_send;
		}

		if (lws_has_buffered_out(wsi))
			n = (int)sendto(wsi->desc.sockfd, (const char *)buf,
#if defined(WIN32)
				(int)
#endif
				   len, 0, sa46_sockaddr(&wsi->udp->sa46_pending),
				   sa46_socklen(&wsi->udp->sa46_pending));
		else
			n = (int)sendto(wsi->desc.sockfd, (const char *)buf,
#if defined(WIN32)
				(int)
#endif
				   len, 0, sa46_sockaddr(&wsi->udp->sa46),
				   sa46_socklen(&wsi->udp->sa46));
	} else
#endif
		if (wsi->role_ops->file_handle)
			n = (int)write((int)(lws_intptr_t)wsi->desc.filefd, buf,
#if defined(WIN32)
				(int)
#endif
					len);
		else
			n = (int)send(wsi->desc.sockfd, (char *)buf,
#if defined(WIN32)
				(int)
#endif
					len, MSG_NOSIGNAL);
//	lwsl_info("%s: sent len %d result %d", __func__, len, n);

#if defined(LWS_WITH_UDP)
post_send:
#endif
	if (n >= 0)
		return n;

	if (LWS_ERRNO == LWS_EAGAIN ||
	    LWS_ERRNO == LWS_EWOULDBLOCK ||
	    LWS_ERRNO == LWS_EINTR) {
		if (LWS_ERRNO == LWS_EWOULDBLOCK) {
			lws_set_blocking_send(wsi);
		}

		return LWS_SSL_CAPABLE_MORE_SERVICE;
	}

	lwsl_wsi_debug(wsi, "ERROR writing len %d to skt fd %d err %d / errno %d",
			    (int)(ssize_t)len, wsi->desc.sockfd, n, LWS_ERRNO);

	return LWS_SSL_CAPABLE_ERROR;
}

int
lws_ssl_pending_no_ssl(struct lws *wsi)
{
	(void)wsi;
#if defined(LWS_PLAT_FREERTOS)
	return 100;
#else
	return 0;
#endif
}