1/*	$OpenBSD: mio_aucat.c,v 1.12 2016/01/09 08:27:24 ratchov Exp $	*/
2/*
3 * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18#include <sys/types.h>
19#include <sys/socket.h>
20#include <sys/un.h>
21#include <netinet/in.h>
22
23#include <errno.h>
24#include <fcntl.h>
25#include <poll.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <unistd.h>
30
31#include "aucat.h"
32#include "debug.h"
33#include "mio_priv.h"
34
35struct mio_aucat_hdl {
36	struct mio_hdl mio;
37	struct aucat aucat;
38	int events;
39};
40
41static void mio_aucat_close(struct mio_hdl *);
42static size_t mio_aucat_read(struct mio_hdl *, void *, size_t);
43static size_t mio_aucat_write(struct mio_hdl *, const void *, size_t);
44static int mio_aucat_nfds(struct mio_hdl *);
45static int mio_aucat_pollfd(struct mio_hdl *, struct pollfd *, int);
46static int mio_aucat_revents(struct mio_hdl *, struct pollfd *);
47
48static struct mio_ops mio_aucat_ops = {
49	mio_aucat_close,
50	mio_aucat_write,
51	mio_aucat_read,
52	mio_aucat_nfds,
53	mio_aucat_pollfd,
54	mio_aucat_revents
55};
56
57/*
58 * execute the next message, return 0 if blocked
59 */
60static int
61mio_aucat_runmsg(struct mio_aucat_hdl *hdl)
62{
63	int delta;
64
65	if (!_aucat_rmsg(&hdl->aucat, &hdl->mio.eof))
66		return 0;
67	switch (ntohl(hdl->aucat.rmsg.cmd)) {
68	case AMSG_DATA:
69		return 1;
70	case AMSG_FLOWCTL:
71		delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
72		hdl->aucat.maxwrite += delta;
73		DPRINTF("aucat: flowctl = %d, maxwrite = %d\n",
74		    delta, hdl->aucat.maxwrite);
75		break;
76	default:
77		DPRINTF("mio_aucat_runmsg: unhandled message %u\n",
78		    hdl->aucat.rmsg.cmd);
79		hdl->mio.eof = 1;
80		return 0;
81	}
82	hdl->aucat.rstate = RSTATE_MSG;
83	hdl->aucat.rtodo = sizeof(struct amsg);
84	return 1;
85}
86
87struct mio_hdl *
88_mio_aucat_open(const char *str, unsigned int mode, int nbio)
89{
90	struct mio_aucat_hdl *hdl;
91
92	hdl = malloc(sizeof(struct mio_aucat_hdl));
93	if (hdl == NULL)
94		return NULL;
95	if (!_aucat_open(&hdl->aucat, str, mode))
96		goto bad;
97	_mio_create(&hdl->mio, &mio_aucat_ops, mode, nbio);
98	if (!_aucat_setfl(&hdl->aucat, 1, &hdl->mio.eof))
99		goto bad;
100	return (struct mio_hdl *)hdl;
101bad:
102	free(hdl);
103	return NULL;
104}
105
106static void
107mio_aucat_close(struct mio_hdl *sh)
108{
109	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
110
111	if (!hdl->mio.eof)
112		_aucat_setfl(&hdl->aucat, 0, &hdl->mio.eof);
113	_aucat_close(&hdl->aucat, hdl->mio.eof);
114	free(hdl);
115}
116
117static size_t
118mio_aucat_read(struct mio_hdl *sh, void *buf, size_t len)
119{
120	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
121
122	while (hdl->aucat.rstate == RSTATE_MSG) {
123		if (!mio_aucat_runmsg(hdl))
124			return 0;
125	}
126	return _aucat_rdata(&hdl->aucat, buf, len, &hdl->mio.eof);
127}
128
129static size_t
130mio_aucat_write(struct mio_hdl *sh, const void *buf, size_t len)
131{
132	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
133	size_t n;
134
135	if (len <= 0 || hdl->aucat.maxwrite <= 0)
136		return 0;
137	if (len > hdl->aucat.maxwrite)
138		len = hdl->aucat.maxwrite;
139	n = _aucat_wdata(&hdl->aucat, buf, len, 1, &hdl->mio.eof);
140	hdl->aucat.maxwrite -= n;
141	return n;
142}
143
144static int
145mio_aucat_nfds(struct mio_hdl *sh)
146{
147	return 1;
148}
149
150static int
151mio_aucat_pollfd(struct mio_hdl *sh, struct pollfd *pfd, int events)
152{
153	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
154
155	hdl->events = events;
156	if (hdl->aucat.maxwrite <= 0)
157		events &= ~POLLOUT;
158	return _aucat_pollfd(&hdl->aucat, pfd, events);
159}
160
161static int
162mio_aucat_revents(struct mio_hdl *sh, struct pollfd *pfd)
163{
164	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
165	int revents = pfd->revents;
166
167	if (revents & POLLIN) {
168		while (hdl->aucat.rstate == RSTATE_MSG) {
169			if (!mio_aucat_runmsg(hdl))
170				break;
171		}
172		if (hdl->aucat.rstate != RSTATE_DATA)
173			revents &= ~POLLIN;
174	}
175	if (revents & POLLOUT) {
176		if (hdl->aucat.maxwrite <= 0)
177			revents &= ~POLLOUT;
178	}
179	if (hdl->mio.eof)
180		return POLLHUP;
181	return revents & (hdl->events | POLLHUP);
182}
183