SRW, CQL, 2003
[yaz-moved-to-github.git] / comstack / unix.c
1 /*
2  * Copyright (c) 1995-2003, Index Data
3  * See the file LICENSE for details.
4  *
5  * $Id: unix.c,v 1.9 2003-01-06 08:20:27 adam Exp $
6  * UNIX socket COMSTACK. By Morten Bøgeskov.
7  */
8 #ifndef WIN32
9
10 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <errno.h>
15 #include <fcntl.h>
16 #include <signal.h>
17
18 #include <sys/socket.h>
19 #include <sys/stat.h>
20 #include <sys/un.h>
21
22 #include <yaz/comstack.h>
23 #include <yaz/unix.h>
24 #include <yaz/log.h>
25
26 /* Chas added the following, so we get the definition of completeBER */
27 #include <yaz/odr.h>
28
29 #ifndef YAZ_SOCKLEN_T
30 #define YAZ_SOCKLEN_T int
31 #endif
32
33 static int unix_close(COMSTACK h);
34 static int unix_put(COMSTACK h, char *buf, int size);
35 static int unix_get(COMSTACK h, char **buf, int *bufsize);
36 static int unix_connect(COMSTACK h, void *address);
37 static int unix_more(COMSTACK h);
38 static int unix_rcvconnect(COMSTACK h);
39 static int unix_bind(COMSTACK h, void *address, int mode);
40 static int unix_listen(COMSTACK h, char *raddr, int *addrlen,
41                 int (*check_ip)(void *cd, const char *a, int len, int type),
42                 void *cd);
43 static int unix_set_blocking(COMSTACK p, int blocking);
44
45
46 static COMSTACK unix_accept(COMSTACK h);
47 static char *unix_addrstr(COMSTACK h);
48 static void *unix_straddr(COMSTACK h, const char *str);
49
50 #ifndef SUN_LEN
51 #define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) \
52                       + strlen ((ptr)->sun_path))
53 #endif
54 #if 0
55 #define TRC(x) x
56 #else
57 #define TRC(X)
58 #endif
59
60 /* this state is used for both SSL and straight TCP/IP */
61 typedef struct unix_state
62 {
63     char *altbuf; /* alternate buffer for surplus data */
64     int altsize;  /* size as xmalloced */
65     int altlen;   /* length of data or 0 if none */
66
67     int written;  /* -1 if we aren't writing */
68     int towrite;  /* to verify against user input */
69     int (*complete)(const unsigned char *buf, int len); /* length/comple. */
70     struct sockaddr_un addr;  /* returned by cs_straddr */
71     char buf[128]; /* returned by cs_addrstr */
72 } unix_state;
73
74 static int unix_init (void)
75 {
76     return 1;
77 }
78
79 /*
80  * This function is always called through the cs_create() macro.
81  * s >= 0: socket has already been established for us.
82  */
83 COMSTACK unix_type(int s, int blocking, int protocol, void *vp)
84 {
85     COMSTACK p;
86     unix_state *state;
87     int new_socket;
88
89     if (!unix_init ())
90         return 0;
91     if (s < 0)
92     {
93         if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
94             return 0;
95         new_socket = 1;
96     }
97     else
98         new_socket = 0;
99     if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
100         return 0;
101     if (!(state = (struct unix_state *)(p->cprivate =
102                                         xmalloc(sizeof(unix_state)))))
103         return 0;
104
105     if (!(p->blocking = blocking))
106     {
107         if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
108             return 0;
109 #ifndef MSG_NOSIGNAL
110         signal (SIGPIPE, SIG_IGN);
111 #endif
112     }
113
114     p->io_pending = 0;
115     p->iofile = s;
116     p->type = unix_type;
117     p->protocol = (enum oid_proto) protocol;
118
119     p->f_connect = unix_connect;
120     p->f_rcvconnect = unix_rcvconnect;
121     p->f_get = unix_get;
122     p->f_put = unix_put;
123     p->f_close = unix_close;
124     p->f_more = unix_more;
125     p->f_bind = unix_bind;
126     p->f_listen = unix_listen;
127     p->f_accept = unix_accept;
128     p->f_addrstr = unix_addrstr;
129     p->f_straddr = unix_straddr;
130     p->f_set_blocking = unix_set_blocking;
131
132     p->state = new_socket ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
133     p->event = CS_NONE;
134     p->cerrno = 0;
135     p->stackerr = 0;
136
137     state->altbuf = 0;
138     state->altsize = state->altlen = 0;
139     state->towrite = state->written = -1;
140     if (protocol == PROTO_WAIS)
141         state->complete = completeWAIS;
142     else
143         state->complete = completeBER;
144
145     p->timeout = COMSTACK_DEFAULT_TIMEOUT;
146     TRC(fprintf(stderr, "Created new UNIX comstack\n"));
147
148     return p;
149 }
150
151
152 static int unix_strtoaddr_ex(const char *str, struct sockaddr_un *add)
153 {
154     char *cp;
155     if (!unix_init ())
156         return 0;
157     TRC(fprintf(stderr, "unix_strtoaddress: %s\n", str ? str : "NULL"));
158     add->sun_family = AF_UNIX;
159     strncpy(add->sun_path, str, sizeof(add->sun_path));
160     cp = strchr (add->sun_path, ':');
161     if (cp)
162         *cp = '\0';
163     return 1;
164 }
165
166 static void *unix_straddr(COMSTACK h, const char *str)
167 {
168     unix_state *sp = (unix_state *)h->cprivate;
169
170     TRC(fprintf(stderr, "unix_straddr: %s\n", str ? str : "NULL"));
171
172     if (!unix_strtoaddr_ex (str, &sp->addr))
173         return 0;
174     return &sp->addr;
175 }
176
177 struct sockaddr_un *unix_strtoaddr(const char *str)
178 {
179     static struct sockaddr_un add;
180
181     TRC(fprintf(stderr, "unix_strtoaddr: %s\n", str ? str : "NULL"));
182
183     if (!unix_strtoaddr_ex (str, &add))
184         return 0;
185     return &add;
186 }
187
188 static int unix_more(COMSTACK h)
189 {
190     unix_state *sp = (unix_state *)h->cprivate;
191
192     return sp->altlen && (*sp->complete)((unsigned char *) sp->altbuf,
193                                          sp->altlen);
194 }
195
196 /*
197  * connect(2) will block (sometimes) - nothing we can do short of doing
198  * weird things like spawning subprocesses or threading or some weird junk
199  * like that.
200  */
201 static int unix_connect(COMSTACK h, void *address)
202 {
203     struct sockaddr_un *add = (struct sockaddr_un *)address;
204     int r;
205
206     TRC(fprintf(stderr, "unix_connect\n"));
207     h->io_pending = 0;
208     if (h->state != CS_ST_UNBND)
209     {
210         h->cerrno = CSOUTSTATE;
211         return -1;
212     }
213     r = connect(h->iofile, (struct sockaddr *) add, SUN_LEN(add));
214     if (r < 0)
215     {
216         if (yaz_errno() == EINPROGRESS)
217         {
218             h->event = CS_CONNECT;
219             h->state = CS_ST_CONNECTING;
220             h->io_pending = CS_WANT_WRITE|CS_WANT_READ;
221             return 1;
222         }
223         h->cerrno = CSYSERR;
224         return -1;
225     }
226     h->event = CS_CONNECT;
227     h->state = CS_ST_CONNECTING;
228
229     return unix_rcvconnect (h);
230 }
231
232 /*
233  * nop
234  */
235 static int unix_rcvconnect(COMSTACK h)
236 {
237     TRC(fprintf(stderr, "unix_rcvconnect\n"));
238
239     if (h->state == CS_ST_DATAXFER)
240         return 0;
241     if (h->state != CS_ST_CONNECTING)
242     {
243         h->cerrno = CSOUTSTATE;
244         return -1;
245     }
246     h->event = CS_DATA;
247     h->state = CS_ST_DATAXFER;
248     return 0;
249 }
250
251 #define CERTF "ztest.pem"
252 #define KEYF "ztest.pem"
253
254 static int unix_bind(COMSTACK h, void *address, int mode)
255 {
256     struct sockaddr *addr = (struct sockaddr *)address;
257     const char * path = ((struct sockaddr_un *)addr)->sun_path;
258     struct stat stat_buf;
259
260     TRC (fprintf (stderr, "unix_bind\n"));
261
262     if(stat(path, &stat_buf) != -1) {
263         struct sockaddr_un socket_unix;
264         int socket_out = -1;
265         if(! S_ISSOCK(stat_buf.st_mode)) {
266             h->cerrno = CSYSERR;
267             yaz_set_errno(EEXIST); /* Not a socket (File exists) */
268             return -1;
269         }
270         if((socket_out = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
271             h->cerrno = CSYSERR;
272             return -1;
273         }
274         socket_unix.sun_family = AF_UNIX;
275         strncpy(socket_unix.sun_path, path, sizeof(socket_unix.sun_path));
276         if(connect(socket_out, (struct sockaddr *) &socket_unix, SUN_LEN(&socket_unix)) < 0) {
277             if(yaz_errno() == ECONNREFUSED) {
278                 TRC (fprintf (stderr, "Socket exists but nobody is listening\n"));
279             } else {
280                 h->cerrno = CSYSERR;
281                 return -1;
282             }
283         } else {
284             close(socket_out);
285             h->cerrno = CSYSERR;
286             yaz_set_errno(EADDRINUSE);
287             return -1;
288         }
289         unlink(path);
290     }
291
292     if (bind(h->iofile, (struct sockaddr *) addr, SUN_LEN((struct sockaddr_un *)addr)))
293     {
294         h->cerrno = CSYSERR;
295         return -1;
296     }
297     if (mode == CS_SERVER && listen(h->iofile, 3) < 0)
298     {
299         h->cerrno = CSYSERR;
300         return -1;
301     }
302     h->state = CS_ST_IDLE;
303     h->event = CS_LISTEN;
304     return 0;
305 }
306
307 static int unix_listen(COMSTACK h, char *raddr, int *addrlen,
308                     int (*check_ip)(void *cd, const char *a, int len, int t),
309                     void *cd)
310 {
311     struct sockaddr_un addr;
312     YAZ_SOCKLEN_T len = SUN_LEN(&addr);
313
314     TRC(fprintf(stderr, "unix_listen pid=%d\n", getpid()));
315     if (h->state != CS_ST_IDLE)
316     {
317         h->cerrno = CSOUTSTATE;
318         return -1;
319     }
320     h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len);
321     if (h->newfd < 0)
322     {
323         if (
324             yaz_errno() == EWOULDBLOCK
325 #ifdef EAGAIN
326 #if EAGAIN != EWOULDBLOCK
327             || yaz_errno() == EAGAIN
328 #endif
329 #endif
330             )
331             h->cerrno = CSNODATA;
332         else
333             h->cerrno = CSYSERR;
334         return -1;
335     }
336     if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_un))
337         memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_un));
338     else if (addrlen)
339         *addrlen = 0;
340     h->state = CS_ST_INCON;
341     return 0;
342 }
343
344 static COMSTACK unix_accept(COMSTACK h)
345 {
346     COMSTACK cnew;
347     unix_state *state, *st = (unix_state *)h->cprivate;
348
349     TRC(fprintf(stderr, "unix_accept\n"));
350     if (h->state == CS_ST_INCON)
351     {
352         if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
353         {
354             h->cerrno = CSYSERR;
355             close(h->newfd);
356             h->newfd = -1;
357             return 0;
358         }
359         memcpy(cnew, h, sizeof(*h));
360         cnew->iofile = h->newfd;
361         cnew->io_pending = 0;
362         if (!(state = (unix_state *)
363               (cnew->cprivate = xmalloc(sizeof(unix_state)))))
364         {
365             h->cerrno = CSYSERR;
366             if (h->newfd != -1)
367             {
368                 close(h->newfd);
369                 h->newfd = -1;
370             }
371             return 0;
372         }
373         if (!cnew->blocking &&
374             (!cnew->blocking && fcntl(cnew->iofile, F_SETFL, O_NONBLOCK) < 0)
375             )
376         {
377             h->cerrno = CSYSERR;
378             if (h->newfd != -1)
379             {
380                 close(h->newfd);
381                 h->newfd = -1;
382             }
383             xfree (cnew);
384             xfree (state);
385             return 0;
386         }
387         h->newfd = -1;
388         state->altbuf = 0;
389         state->altsize = state->altlen = 0;
390         state->towrite = state->written = -1;
391         state->complete = st->complete;
392         cnew->state = CS_ST_ACCEPT;
393         cnew->event = CS_NONE;
394         h->state = CS_ST_IDLE;
395
396         h = cnew;
397     }
398     if (h->state == CS_ST_ACCEPT)
399     {
400     }
401     else
402     {
403         h->cerrno = CSOUTSTATE;
404         return 0;
405     }
406     h->io_pending = 0;
407     h->state = CS_ST_DATAXFER;
408     h->event = CS_DATA;
409     return h;
410 }
411
412 #define CS_UNIX_BUFCHUNK 4096
413
414 /*
415  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
416  * 0=connection closed.
417  */
418 static int unix_get(COMSTACK h, char **buf, int *bufsize)
419 {
420     unix_state *sp = (unix_state *)h->cprivate;
421     char *tmpc;
422     int tmpi, berlen, rest, req, tomove;
423     int hasread = 0, res;
424
425     TRC(fprintf(stderr, "unix_get: bufsize=%d\n", *bufsize));
426     if (sp->altlen) /* switch buffers */
427     {
428         TRC(fprintf(stderr, "  %d bytes in altbuf (0x%x)\n", sp->altlen,
429                     (unsigned) sp->altbuf));
430         tmpc = *buf;
431         tmpi = *bufsize;
432         *buf = sp->altbuf;
433         *bufsize = sp->altsize;
434         hasread = sp->altlen;
435         sp->altlen = 0;
436         sp->altbuf = tmpc;
437         sp->altsize = tmpi;
438     }
439     h->io_pending = 0;
440     while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
441     {
442         if (!*bufsize)
443         {
444             if (!(*buf = (char *)xmalloc(*bufsize = CS_UNIX_BUFCHUNK)))
445                 return -1;
446         }
447         else if (*bufsize - hasread < CS_UNIX_BUFCHUNK)
448             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
449                 return -1;
450         res = recv(h->iofile, *buf + hasread, CS_UNIX_BUFCHUNK, 0);
451         TRC(fprintf(stderr, "  recv res=%d, hasread=%d\n", res, hasread));
452         if (res < 0)
453         {
454             if (yaz_errno() == EWOULDBLOCK
455 #ifdef EAGAIN
456 #if EAGAIN != EWOULDBLOCK
457                 || yaz_errno() == EAGAIN
458 #endif
459 #endif
460                 || yaz_errno() == EINPROGRESS
461                 )
462             {
463                 h->io_pending = CS_WANT_READ;
464                 break;
465             }
466             else if (yaz_errno() == 0)
467                 continue;
468             else
469                 return -1;
470         }
471         else if (!res)
472             return 0;
473         hasread += res;
474     }
475     TRC (fprintf (stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
476                   hasread, berlen));
477     /* move surplus buffer (or everything if we didn't get a BER rec.) */
478     if (hasread > berlen)
479     {
480         tomove = req = hasread - berlen;
481         rest = tomove % CS_UNIX_BUFCHUNK;
482         if (rest)
483             req += CS_UNIX_BUFCHUNK - rest;
484         if (!sp->altbuf)
485         {
486             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
487                 return -1;
488         } else if (sp->altsize < req)
489             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
490                 return -1;
491         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(0x%x)\n", tomove,
492                     (unsigned) sp->altbuf));
493         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
494     }
495     if (berlen < CS_UNIX_BUFCHUNK - 1)
496         *(*buf + berlen) = '\0';
497     return berlen ? berlen : 1;
498 }
499
500
501
502 /*
503  * Returns 1, 0 or -1
504  * In nonblocking mode, you must call again with same buffer while
505  * return value is 1.
506  */
507 static int unix_put(COMSTACK h, char *buf, int size)
508 {
509     int res;
510     struct unix_state *state = (struct unix_state *)h->cprivate;
511
512     TRC(fprintf(stderr, "unix_put: size=%d\n", size));
513     h->io_pending = 0;
514     h->event = CS_DATA;
515     if (state->towrite < 0)
516     {
517         state->towrite = size;
518         state->written = 0;
519     }
520     else if (state->towrite != size)
521     {
522         h->cerrno = CSWRONGBUF;
523         return -1;
524     }
525     while (state->towrite > state->written)
526     {
527         if ((res =
528              send(h->iofile, buf + state->written, size -
529                   state->written,
530 #ifdef MSG_NOSIGNAL
531                   MSG_NOSIGNAL
532 #else
533                   0
534 #endif
535                  )) < 0)
536         {
537             if (
538                 yaz_errno() == EWOULDBLOCK
539 #ifdef EAGAIN
540 #if EAGAIN != EWOULDBLOCK
541                 || yaz_errno() == EAGAIN
542 #endif
543 #endif
544                 )
545             {
546                 TRC(fprintf(stderr, "  Flow control stop\n"));
547                 h->io_pending = CS_WANT_WRITE;
548                 return 1;
549             }
550             h->cerrno = CSYSERR;
551             return -1;
552         }
553         state->written += res;
554         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
555                     res, state->written, size));
556     }
557     state->towrite = state->written = -1;
558     TRC(fprintf(stderr, "  Ok\n"));
559     return 0;
560 }
561
562 static int unix_close(COMSTACK h)
563 {
564     unix_state *sp = (struct unix_state *)h->cprivate;
565
566     TRC(fprintf(stderr, "unix_close\n"));
567     if (h->iofile != -1)
568     {
569         close(h->iofile);
570     }
571     if (sp->altbuf)
572         xfree(sp->altbuf);
573     xfree(sp);
574     xfree(h);
575     return 0;
576 }
577
578 static char *unix_addrstr(COMSTACK h)
579 {
580     unix_state *sp = (struct unix_state *)h->cprivate;
581     char *buf = sp->buf;
582     sprintf(buf, "unix:%s", sp->addr.sun_path);
583     return buf;
584 }
585
586 static int unix_set_blocking(COMSTACK p, int blocking)
587 {
588     unsigned long flag;
589
590     if (p->blocking == blocking)
591         return 1;
592     flag = fcntl(p->iofile, F_GETFL, 0);
593     if(!blocking)
594         flag = flag & ~O_NONBLOCK;
595     else
596         flag = flag | O_NONBLOCK;
597     if (fcntl(p->iofile, F_SETFL, flag) < 0)
598         return 0;
599     p->blocking = blocking;
600     return 1;
601 }
602 #endif