lib: Use abort() instead of exit() when smalloc fails.
[ashd.git] / lib / mtio.c
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 }