[ashd.git] / lib / mtio.c

/*
    ashd - A Sane HTTP Daemon
    Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>

#include <log.h>
#include <utils.h>
#include <mt.h>
#include <mtio.h>
#include <bufio.h>

static ssize_t mtrecv(struct stdiofd *d, void *buf, size_t len)
{
    struct msghdr msg;
    char cbuf[512];
    struct cmsghdr *cmsg;
    struct iovec bufvec;
    socklen_t clen;
    ssize_t ret;
    int i, *fds;
    
    msg = (struct msghdr){};
    msg.msg_iov = &bufvec;
    msg.msg_iovlen = 1;
    bufvec.iov_base = buf;
    bufvec.iov_len = len;
    msg.msg_control = cbuf;
    msg.msg_controllen = sizeof(cbuf);
    if((ret = recvmsg(d->fd, &msg, MSG_DONTWAIT)) < 0)
	return(ret);
    for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
	if((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SCM_RIGHTS)) {
	    fds = (int *)CMSG_DATA(cmsg);
	    clen = (cmsg->cmsg_len - ((char *)fds - (char *)cmsg)) / sizeof(*fds);
	    for(i = 0; i < clen; i++) {
		if(d->rights < 0)
		    d->rights = fds[i];
		else
		    close(fds[i]);
	    }
	}
    }
    return(ret);
}

static ssize_t mtread(void *cookie, void *buf, size_t len)
{
    struct stdiofd *d = cookie;
    int ev;
    ssize_t ret;
    
    while(1) {
	if(d->sock)
	    ret = mtrecv(d, buf, len);
	else
	    ret = read(d->fd, buf, len);
	if((ret < 0) && (errno == EAGAIN)) {
	    ev = block(d->fd, EV_READ, d->timeout);
	    if(ev < 0) {
		/* If we just go on, we should get the real error. */
		continue;
	    } else if(ev == 0) {
		errno = ETIMEDOUT;
		return(-1);
	    } else {
		continue;
	    }
	} else {
	    return(ret);
	}
    }
}

static ssize_t mtsend(struct stdiofd *d, const void *buf, size_t len)
{
    struct msghdr msg;
    struct cmsghdr *cmsg;
    char cbuf[CMSG_SPACE(sizeof(int))];
    struct iovec bufvec;
    ssize_t ret;
    int cr;
    
    msg = (struct msghdr){};
    msg.msg_iov = &bufvec;
    msg.msg_iovlen = 1;
    bufvec.iov_base = (void *)buf;
    bufvec.iov_len = len;
    cr = -1;
    if(d->sendrights >= 0) {
	msg.msg_control = cbuf;
	msg.msg_controllen = sizeof(cbuf);
	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	*((int *)CMSG_DATA(cmsg)) = d->sendrights;
	cr = d->sendrights;
	d->sendrights = -1;
	msg.msg_controllen = cmsg->cmsg_len;
    }
    ret = sendmsg(d->fd, &msg, MSG_DONTWAIT | MSG_NOSIGNAL);
    if(cr >= 0)
	close(cr);
    return(ret);
}

static ssize_t mtwrite(void *cookie, const void *buf, size_t len)
{
    struct stdiofd *d = cookie;
    int ev;
    ssize_t ret;
    
    while(1) {
	if(d->sock)
	    ret = mtsend(d, buf, len);
	else
	    ret = write(d->fd, buf, len);
	if((ret < 0) && (errno == EAGAIN)) {
	    ev = block(d->fd, EV_WRITE, d->timeout);
	    if(ev < 0) {
		/* If we just go on, we should get the real error. */
		continue;
	    } else if(ev == 0) {
		errno = ETIMEDOUT;
		return(-1);
	    }
	} else {
	    return(ret);
	}
    }
}

static int mtclose(void *cookie)
{
    struct stdiofd *d = cookie;
    
    close(d->fd);
    if(d->rights >= 0)
	close(d->rights);
    if(d->sendrights >= 0)
	close(d->sendrights);
    free(d);
    return(0);
}

FILE *mtstdopen(int fd, int issock, int timeout, char *mode, struct stdiofd **infop)
{
    struct stdiofd *d;
    FILE *ret;
    int r, w;
    
    if(!strcmp(mode, "r")) {
	r = 1; w = 0;
    } else if(!strcmp(mode, "w")) {
	r = 0; w = 1;
    } else if(!strcmp(mode, "r+")) {
	r = w = 1;
    } else {
	return(NULL);
    }
    omalloc(d);
    d->fd = fd;
    d->sock = issock;
    d->timeout = timeout;
    d->rights = d->sendrights = -1;
    if(!(ret = funstdio(d, r?mtread:NULL, w?mtwrite:NULL, NULL, mtclose))) {
	free(d);
	return(NULL);
    }
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
    if(infop)
	*infop = d;
    return(ret);
}

struct bufio *mtbioopen(int fd, int issock, int timeout, char *mode, struct stdiofd **infop)
{
    static struct bufioops ops = {
	.read = mtread, .write = mtwrite, .close = mtclose,
    };
    struct stdiofd *d;
    struct bufio *ret;
    
    if(!strcmp(mode, "r")) {
    } else if(!strcmp(mode, "w")) {
    } else if(!strcmp(mode, "r+")) {
    } else {
	return(NULL);
    }
    omalloc(d);
    d->fd = fd;
    d->sock = issock;
    d->timeout = timeout;
    d->rights = d->sendrights = -1;
    if(!(ret = bioopen(d, &ops))) {
	free(d);
	return(NULL);
    }
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
    if(infop)
	*infop = d;
    return(ret);
}

struct pipe {
    struct charbuf data;
    size_t bufmax;
    int closed;
    struct muth *r, *w;
};

static void freepipe(struct pipe *p)
{
    buffree(p->data);
    free(p);
}

static ssize_t piperead(void *pdata, void *buf, size_t len)
{
    struct pipe *p = pdata;
    ssize_t ret;
    
    while(p->data.d == 0) {
	if(p->closed & 2)
	    return(0);
	if(p->r) {
	    errno = EBUSY;
	    return(-1);
	}
	p->r = current;
	yield();
	p->r = NULL;
    }
    ret = min(len, p->data.d);
    memcpy(buf, p->data.b, ret);
    memmove(p->data.b, p->data.b + ret, p->data.d -= ret);
    if(p->w)
	resume(p->w, 0);
    return(ret);
}

static int piperclose(void *pdata)
{
    struct pipe *p = pdata;
    
    if(p->closed & 2) {
	freepipe(p);
    } else {
	p->closed |= 1;
	if(p->w)
	    resume(p->w, 0);
    }
    return(0);
}

static ssize_t pipewrite(void *pdata, const void *buf, size_t len)
{
    struct pipe *p = pdata;
    ssize_t ret;
    
    if(p->closed & 1) {
	errno = EPIPE;
	return(-1);
    }
    while(p->data.d >= p->bufmax) {
	if(p->w) {
	    errno = EBUSY;
	    return(-1);
	}
	p->w = current;
	yield();
	p->w = NULL;
	if(p->closed & 1) {
	    errno = EPIPE;
	    return(-1);
	}
    }
    ret = min(len, p->bufmax - p->data.d);
    sizebuf(p->data, p->data.d + ret);
    memcpy(p->data.b + p->data.d, buf, ret);
    p->data.d += ret;
    if(p->r)
	resume(p->r, 0);
    return(ret);
}

static int pipewclose(void *pdata)
{
    struct pipe *p = pdata;
    
    if(p->closed & 1) {
	freepipe(p);
    } else {
	p->closed |= 2;
	if(p->r)
	    resume(p->r, 0);
    }
    return(0);
}

void mtiopipe(FILE **read, FILE **write)
{
    struct pipe *p;
    
    omalloc(p);
    p->bufmax = 4096;
    *read = funstdio(p, piperead, NULL, NULL, piperclose);
    *write = funstdio(p, NULL, pipewrite, NULL, pipewclose);
}
Commit	Line	Data
	1	/*
	2	ashd - A Sane HTTP Daemon
	3	Copyright (C) 2008 Fredrik Tolf <fredrik@dolda2000.com>
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#ifdef HAVE_CONFIG_H
	20	#include <config.h>
	21	#endif
	22	#include <stdlib.h>
	23	#include <stdio.h>
	24	#include <unistd.h>
	25	#include <fcntl.h>
	26	#include <string.h>
	27	#include <errno.h>
	28	#include <sys/socket.h>
	29
	30	#include <log.h>
	31	#include <utils.h>
	32	#include <mt.h>
	33	#include <mtio.h>
	34	#include <bufio.h>
	35
	36	static ssize_t mtrecv(struct stdiofd d, void buf, size_t len)
	37	{
	38	struct msghdr msg;
	39	char cbuf[512];
	40	struct cmsghdr *cmsg;
	41	struct iovec bufvec;
	42	socklen_t clen;
	43	ssize_t ret;
	44	int i, *fds;
	45
	46	msg = (struct msghdr){};
	47	msg.msg_iov = &bufvec;
	48	msg.msg_iovlen = 1;
	49	bufvec.iov_base = buf;
	50	bufvec.iov_len = len;
	51	msg.msg_control = cbuf;
	52	msg.msg_controllen = sizeof(cbuf);
	53	if((ret = recvmsg(d->fd, &msg, MSG_DONTWAIT)) < 0)
	54	return(ret);
	55	for(cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
	56	if((cmsg->cmsg_level == SOL_SOCKET) && (cmsg->cmsg_type == SCM_RIGHTS)) {
	57	fds = (int *)CMSG_DATA(cmsg);
	58	clen = (cmsg->cmsg_len - ((char )fds - (char )cmsg)) / sizeof(*fds);
	59	for(i = 0; i < clen; i++) {
	60	if(d->rights < 0)
	61	d->rights = fds[i];
	62	else
	63	close(fds[i]);
	64	}
	65	}
	66	}
	67	return(ret);
	68	}
	69
	70	static ssize_t mtread(void cookie, void buf, size_t len)
	71	{
	72	struct stdiofd *d = cookie;
	73	int ev;
	74	ssize_t ret;
	75
	76	while(1) {
	77	if(d->sock)
	78	ret = mtrecv(d, buf, len);
	79	else
	80	ret = read(d->fd, buf, len);
	81	if((ret < 0) && (errno == EAGAIN)) {
	82	ev = block(d->fd, EV_READ, d->timeout);
	83	if(ev < 0) {
	84	/* If we just go on, we should get the real error. */
	85	continue;
	86	} else if(ev == 0) {
	87	errno = ETIMEDOUT;
	88	return(-1);
	89	} else {
	90	continue;
	91	}
	92	} else {
	93	return(ret);
	94	}
	95	}
	96	}
	97
	98	static ssize_t mtsend(struct stdiofd d, const void buf, size_t len)
	99	{
	100	struct msghdr msg;
	101	struct cmsghdr *cmsg;
	102	char cbuf[CMSG_SPACE(sizeof(int))];
	103	struct iovec bufvec;
	104	ssize_t ret;
	105	int cr;
	106
	107	msg = (struct msghdr){};
	108	msg.msg_iov = &bufvec;
	109	msg.msg_iovlen = 1;
	110	bufvec.iov_base = (void *)buf;
	111	bufvec.iov_len = len;
	112	cr = -1;
	113	if(d->sendrights >= 0) {
	114	msg.msg_control = cbuf;
	115	msg.msg_controllen = sizeof(cbuf);
	116	cmsg = CMSG_FIRSTHDR(&msg);
	117	cmsg->cmsg_level = SOL_SOCKET;
	118	cmsg->cmsg_type = SCM_RIGHTS;
	119	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	120	((int )CMSG_DATA(cmsg)) = d->sendrights;
	121	cr = d->sendrights;
	122	d->sendrights = -1;
	123	msg.msg_controllen = cmsg->cmsg_len;
	124	}
	125	ret = sendmsg(d->fd, &msg, MSG_DONTWAIT \| MSG_NOSIGNAL);
	126	if(cr >= 0)
	127	close(cr);
	128	return(ret);
	129	}
	130
	131	static ssize_t mtwrite(void cookie, const void buf, size_t len)
	132	{
	133	struct stdiofd *d = cookie;
	134	int ev;
	135	ssize_t ret;
	136
	137	while(1) {
	138	if(d->sock)
	139	ret = mtsend(d, buf, len);
	140	else
	141	ret = write(d->fd, buf, len);
	142	if((ret < 0) && (errno == EAGAIN)) {
	143	ev = block(d->fd, EV_WRITE, d->timeout);
	144	if(ev < 0) {
	145	/* If we just go on, we should get the real error. */
	146	continue;
	147	} else if(ev == 0) {
	148	errno = ETIMEDOUT;
	149	return(-1);
	150	}
	151	} else {
	152	return(ret);
	153	}
	154	}
	155	}
	156
	157	static int mtclose(void *cookie)
	158	{
	159	struct stdiofd *d = cookie;
	160
	161	close(d->fd);
	162	if(d->rights >= 0)
	163	close(d->rights);
	164	if(d->sendrights >= 0)
	165	close(d->sendrights);
	166	free(d);
	167	return(0);
	168	}
	169
	170	FILE mtstdopen(int fd, int issock, int timeout, char mode, struct stdiofd **infop)
	171	{
	172	struct stdiofd *d;
	173	FILE *ret;
	174	int r, w;
	175
	176	if(!strcmp(mode, "r")) {
	177	r = 1; w = 0;
	178	} else if(!strcmp(mode, "w")) {
	179	r = 0; w = 1;
	180	} else if(!strcmp(mode, "r+")) {
	181	r = w = 1;
	182	} else {
	183	return(NULL);
	184	}
	185	omalloc(d);
	186	d->fd = fd;
	187	d->sock = issock;
	188	d->timeout = timeout;
	189	d->rights = d->sendrights = -1;
	190	if(!(ret = funstdio(d, r?mtread:NULL, w?mtwrite:NULL, NULL, mtclose))) {
	191	free(d);
	192	return(NULL);
	193	}
	194	fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) \| O_NONBLOCK);
	195	if(infop)
	196	*infop = d;
	197	return(ret);
	198	}
	199
	200	struct bufio mtbioopen(int fd, int issock, int timeout, char mode, struct stdiofd **infop)
	201	{
	202	static struct bufioops ops = {
	203	.read = mtread, .write = mtwrite, .close = mtclose,
	204	};
	205	struct stdiofd *d;
	206	struct bufio *ret;
	207
	208	if(!strcmp(mode, "r")) {
	209	} else if(!strcmp(mode, "w")) {
	210	} else if(!strcmp(mode, "r+")) {
	211	} else {
	212	return(NULL);
	213	}
	214	omalloc(d);
	215	d->fd = fd;
	216	d->sock = issock;
	217	d->timeout = timeout;
	218	d->rights = d->sendrights = -1;
	219	if(!(ret = bioopen(d, &ops))) {
	220	free(d);
	221	return(NULL);
	222	}
	223	fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) \| O_NONBLOCK);
	224	if(infop)
	225	*infop = d;
	226	return(ret);
	227	}
	228
	229	struct pipe {
	230	struct charbuf data;
	231	size_t bufmax;
	232	int closed;
	233	struct muth r, w;
	234	};
	235
	236	static void freepipe(struct pipe *p)
	237	{
	238	buffree(p->data);
	239	free(p);
	240	}
	241
	242	static ssize_t piperead(void pdata, void buf, size_t len)
	243	{
	244	struct pipe *p = pdata;
	245	ssize_t ret;
	246
	247	while(p->data.d == 0) {
	248	if(p->closed & 2)
	249	return(0);
	250	if(p->r) {
	251	errno = EBUSY;
	252	return(-1);
	253	}
	254	p->r = current;
	255	yield();
	256	p->r = NULL;
	257	}
	258	ret = min(len, p->data.d);
	259	memcpy(buf, p->data.b, ret);
	260	memmove(p->data.b, p->data.b + ret, p->data.d -= ret);
	261	if(p->w)
	262	resume(p->w, 0);
	263	return(ret);
	264	}
	265
	266	static int piperclose(void *pdata)
	267	{
	268	struct pipe *p = pdata;
	269
	270	if(p->closed & 2) {
	271	freepipe(p);
	272	} else {
	273	p->closed \|= 1;
	274	if(p->w)
	275	resume(p->w, 0);
	276	}
	277	return(0);
	278	}
	279
	280	static ssize_t pipewrite(void pdata, const void buf, size_t len)
	281	{
	282	struct pipe *p = pdata;
	283	ssize_t ret;
	284
	285	if(p->closed & 1) {
	286	errno = EPIPE;
	287	return(-1);
	288	}
	289	while(p->data.d >= p->bufmax) {
	290	if(p->w) {
	291	errno = EBUSY;
	292	return(-1);
	293	}
	294	p->w = current;
	295	yield();
	296	p->w = NULL;
	297	if(p->closed & 1) {
	298	errno = EPIPE;
	299	return(-1);
	300	}
	301	}
	302	ret = min(len, p->bufmax - p->data.d);
	303	sizebuf(p->data, p->data.d + ret);
	304	memcpy(p->data.b + p->data.d, buf, ret);
	305	p->data.d += ret;
	306	if(p->r)
	307	resume(p->r, 0);
	308	return(ret);
	309	}
	310
	311	static int pipewclose(void *pdata)
	312	{
	313	struct pipe *p = pdata;
	314
	315	if(p->closed & 1) {
	316	freepipe(p);
	317	} else {
	318	p->closed \|= 2;
	319	if(p->r)
	320	resume(p->r, 0);
	321	}
	322	return(0);
	323	}
	324
	325	void mtiopipe(FILE read, FILE write)
	326	{
	327	struct pipe *p;
	328
	329	omalloc(p);
	330	p->bufmax = 4096;
	331	*read = funstdio(p, piperead, NULL, NULL, piperclose);
	332	*write = funstdio(p, NULL, pipewrite, NULL, pipewclose);
	333	}