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