Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libsndio/mio_aucat.c	Lines:	0	59	0.0 %
Date:	2017-11-07	Branches:	0	43	0.0 %


/*	$OpenBSD: mio_aucat.c,v 1.12 2016/01/09 08:27:24 ratchov Exp $	*/
/*
 * Copyright (c) 2008 Alexandre Ratchov <alex@caoua.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>

#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "aucat.h"
#include "debug.h"
#include "mio_priv.h"

struct mio_aucat_hdl {
	struct mio_hdl mio;
	struct aucat aucat;
	int events;
};

static void mio_aucat_close(struct mio_hdl *);
static size_t mio_aucat_read(struct mio_hdl *, void *, size_t);
static size_t mio_aucat_write(struct mio_hdl *, const void *, size_t);
static int mio_aucat_nfds(struct mio_hdl *);
static int mio_aucat_pollfd(struct mio_hdl *, struct pollfd *, int);
static int mio_aucat_revents(struct mio_hdl *, struct pollfd *);

static struct mio_ops mio_aucat_ops = {
	mio_aucat_close,
	mio_aucat_write,
	mio_aucat_read,
	mio_aucat_nfds,
	mio_aucat_pollfd,
	mio_aucat_revents
};

/*
 * execute the next message, return 0 if blocked
 */
static int
mio_aucat_runmsg(struct mio_aucat_hdl *hdl)
{
	int delta;

	if (!_aucat_rmsg(&hdl->aucat, &hdl->mio.eof))
		return 0;
	switch (ntohl(hdl->aucat.rmsg.cmd)) {
	case AMSG_DATA:
		return 1;
	case AMSG_FLOWCTL:
		delta = ntohl(hdl->aucat.rmsg.u.ts.delta);
		hdl->aucat.maxwrite += delta;
		DPRINTF("aucat: flowctl = %d, maxwrite = %d\n",
		    delta, hdl->aucat.maxwrite);
		break;
	default:
		DPRINTF("mio_aucat_runmsg: unhandled message %u\n",
		    hdl->aucat.rmsg.cmd);
		hdl->mio.eof = 1;
		return 0;
	}
	hdl->aucat.rstate = RSTATE_MSG;
	hdl->aucat.rtodo = sizeof(struct amsg);
	return 1;
}

struct mio_hdl *
_mio_aucat_open(const char *str, unsigned int mode, int nbio)
{
	struct mio_aucat_hdl *hdl;

	hdl = malloc(sizeof(struct mio_aucat_hdl));
	if (hdl == NULL)
		return NULL;
	if (!_aucat_open(&hdl->aucat, str, mode))
		goto bad;
	_mio_create(&hdl->mio, &mio_aucat_ops, mode, nbio);
	if (!_aucat_setfl(&hdl->aucat, 1, &hdl->mio.eof))
		goto bad;
	return (struct mio_hdl *)hdl;
bad:
	free(hdl);
	return NULL;
}

static void
mio_aucat_close(struct mio_hdl *sh)
{
	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;

	if (!hdl->mio.eof)
		_aucat_setfl(&hdl->aucat, 0, &hdl->mio.eof);
	_aucat_close(&hdl->aucat, hdl->mio.eof);
	free(hdl);
}

static size_t
mio_aucat_read(struct mio_hdl *sh, void *buf, size_t len)
{
	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;

	while (hdl->aucat.rstate == RSTATE_MSG) {
		if (!mio_aucat_runmsg(hdl))
			return 0;
	}
	return _aucat_rdata(&hdl->aucat, buf, len, &hdl->mio.eof);
}

static size_t
mio_aucat_write(struct mio_hdl *sh, const void *buf, size_t len)
{
	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
	size_t n;

	if (len <= 0 || hdl->aucat.maxwrite <= 0)
		return 0;
	if (len > hdl->aucat.maxwrite)
		len = hdl->aucat.maxwrite;
	n = _aucat_wdata(&hdl->aucat, buf, len, 1, &hdl->mio.eof);
	hdl->aucat.maxwrite -= n;
	return n;
}

static int
mio_aucat_nfds(struct mio_hdl *sh)
{
	return 1;
}

static int
mio_aucat_pollfd(struct mio_hdl *sh, struct pollfd *pfd, int events)
{
	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;

	hdl->events = events;
	if (hdl->aucat.maxwrite <= 0)
		events &= ~POLLOUT;
	return _aucat_pollfd(&hdl->aucat, pfd, events);
}

static int
mio_aucat_revents(struct mio_hdl *sh, struct pollfd *pfd)
{
	struct mio_aucat_hdl *hdl = (struct mio_aucat_hdl *)sh;
	int revents = pfd->revents;

	if (revents & POLLIN) {
		while (hdl->aucat.rstate == RSTATE_MSG) {
			if (!mio_aucat_runmsg(hdl))
				break;
		}
		if (hdl->aucat.rstate != RSTATE_DATA)
			revents &= ~POLLIN;
	}
	if (revents & POLLOUT) {
		if (hdl->aucat.maxwrite <= 0)
			revents &= ~POLLOUT;
	}
	if (hdl->mio.eof)
		return POLLHUP;
	return revents & (hdl->events | POLLHUP);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
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
35			struct mio_aucat_hdl {
36			struct mio_hdl mio;
37			struct aucat aucat;
38			int events;
39			};
40
41			static void mio_aucat_close(struct mio_hdl *);
42			static size_t mio_aucat_read(struct mio_hdl , void , size_t);
43			static size_t mio_aucat_write(struct mio_hdl , const void , size_t);
44			static int mio_aucat_nfds(struct mio_hdl *);
45			static int mio_aucat_pollfd(struct mio_hdl , struct pollfd , int);
46			static int mio_aucat_revents(struct mio_hdl , struct pollfd );
47
48			static 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			*/
60			static int
61			mio_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
87			struct 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;
101			bad:
102			free(hdl);
103			return NULL;
104			}
105
106			static void
107			mio_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
117			static size_t
118			mio_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
129			static size_t
130			mio_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
144			static int
145			mio_aucat_nfds(struct mio_hdl *sh)
146			{
147			return 1;
148			}
149
150			static int
151			mio_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
161			static int
162			mio_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			}