Update source headers for 2008. Omit CVS ID keyword subst.
[yaz-moved-to-github.git] / src / unix.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2008 Index Data
3  * See the file LICENSE for details.
4  */
5 /**
6  * \file unix.c
7  * \brief Implements UNIX domain socket COMSTACK
8  */
9
10 #ifndef WIN32
11
12 #include <stdio.h>
13 #include <string.h>
14 #include <stdlib.h>
15 #include <errno.h>
16 #if HAVE_SYS_TYPES_H
17 #include <sys/types.h>
18 #endif
19 #if HAVE_UNISTD_H
20 #include <unistd.h>
21 #endif
22 #if HAVE_SYS_SOCKET_H
23 #include <sys/socket.h>
24 #endif
25 #include <fcntl.h>
26 #include <signal.h>
27
28 #include <grp.h>
29 #if HAVE_PWD_H
30 #include <pwd.h>
31 #endif
32
33 #if HAVE_SYS_STAT_H
34 #include <sys/stat.h>
35 #endif
36 #if HAVE_SYS_UN_H
37 #include <sys/un.h>
38 #endif
39
40 #include <yaz/unix.h>
41 #include <yaz/nmem.h>
42
43 #ifndef YAZ_SOCKLEN_T
44 #define YAZ_SOCKLEN_T int
45 #endif
46
47 /* stat(2) masks: S_IFMT and S_IFSOCK may not be defined in gcc -ansi mode */
48 #if __STRICT_ANSI__
49 #ifndef S_IFSOCK
50 #define S_IFMT   0170000
51 #define S_IFSOCK 0140000
52 #endif
53 #endif
54
55 static int unix_close(COMSTACK h);
56 static int unix_put(COMSTACK h, char *buf, int size);
57 static int unix_get(COMSTACK h, char **buf, int *bufsize);
58 static int unix_connect(COMSTACK h, void *address);
59 static int unix_more(COMSTACK h);
60 static int unix_rcvconnect(COMSTACK h);
61 static int unix_bind(COMSTACK h, void *address, int mode);
62 static int unix_listen(COMSTACK h, char *raddr, int *addrlen,
63                 int (*check_ip)(void *cd, const char *a, int len, int type),
64                 void *cd);
65 static int unix_set_blocking(COMSTACK p, int blocking);
66
67 static COMSTACK unix_accept(COMSTACK h);
68 static char *unix_addrstr(COMSTACK h);
69 static void *unix_straddr(COMSTACK h, const char *str);
70
71 #ifndef SUN_LEN
72 #define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) \
73                       + strlen ((ptr)->sun_path))
74 #endif
75 #if 0
76 #define TRC(x) x
77 #else
78 #define TRC(X)
79 #endif
80
81 /* this state is used for both SSL and straight TCP/IP */
82 typedef struct unix_state
83 {
84     char *altbuf; /* alternate buffer for surplus data */
85     int altsize;  /* size as xmalloced */
86     int altlen;   /* length of data or 0 if none */
87
88     int written;  /* -1 if we aren't writing */
89     int towrite;  /* to verify against user input */
90     int (*complete)(const char *buf, int len); /* length/complete. */
91     struct sockaddr_un addr;  /* returned by cs_straddr */
92     int uid;
93     int gid;
94     int umask;
95     char buf[128]; /* returned by cs_addrstr */
96 } unix_state;
97
98 static int unix_init (void)
99 {
100     return 1;
101 }
102
103 /*
104  * This function is always called through the cs_create() macro.
105  * s >= 0: socket has already been established for us.
106  */
107 COMSTACK unix_type(int s, int flags, int protocol, void *vp)
108 {
109     COMSTACK p;
110     unix_state *state;
111     int new_socket;
112
113     if (!unix_init ())
114         return 0;
115     if (s < 0)
116     {
117         if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
118             return 0;
119         new_socket = 1;
120     }
121     else
122         new_socket = 0;
123     if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
124         return 0;
125     if (!(state = (struct unix_state *)(p->cprivate =
126                                         xmalloc(sizeof(unix_state)))))
127         return 0;
128
129     p->flags = flags;
130     if (!(p->flags&CS_FLAGS_BLOCKING))
131     {
132         if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
133             return 0;
134 #ifndef MSG_NOSIGNAL
135         signal (SIGPIPE, SIG_IGN);
136 #endif
137     }
138
139     p->io_pending = 0;
140     p->iofile = s;
141     p->type = unix_type;
142     p->protocol = (enum oid_proto) protocol;
143
144     p->f_connect = unix_connect;
145     p->f_rcvconnect = unix_rcvconnect;
146     p->f_get = unix_get;
147     p->f_put = unix_put;
148     p->f_close = unix_close;
149     p->f_more = unix_more;
150     p->f_bind = unix_bind;
151     p->f_listen = unix_listen;
152     p->f_accept = unix_accept;
153     p->f_addrstr = unix_addrstr;
154     p->f_straddr = unix_straddr;
155     p->f_set_blocking = unix_set_blocking;
156
157     p->state = new_socket ? CS_ST_UNBND : CS_ST_IDLE; /* state of line */
158     p->event = CS_NONE;
159     p->cerrno = 0;
160     p->stackerr = 0;
161     p->user = 0;
162
163     state->altbuf = 0;
164     state->altsize = state->altlen = 0;
165     state->towrite = state->written = -1;
166     if (protocol == PROTO_WAIS)
167         state->complete = completeWAIS;
168     else
169         state->complete = cs_complete_auto;
170
171     p->timeout = COMSTACK_DEFAULT_TIMEOUT;
172     TRC(fprintf(stderr, "Created new UNIX comstack\n"));
173
174     return p;
175 }
176
177
178 static int unix_strtoaddr_ex(const char *str, struct sockaddr_un *add)
179 {
180     char *cp;
181     if (!unix_init ())
182         return 0;
183     TRC(fprintf(stderr, "unix_strtoaddress: %s\n", str ? str : "NULL"));
184     add->sun_family = AF_UNIX;
185     strncpy(add->sun_path, str, sizeof(add->sun_path)-1);
186     add->sun_path[sizeof(add->sun_path)-1] = 0;
187     cp = strchr (add->sun_path, ':');
188     if (cp)
189         *cp = '\0';
190     return 1;
191 }
192
193 static void *unix_straddr1(COMSTACK h, const char *str, char *f)
194 {
195     unix_state *sp = (unix_state *)h->cprivate;
196     char * s = f;
197     const char * file = NULL;
198     char * eol;
199
200     sp->uid = sp->gid = sp->umask = -1;
201
202     if ((eol = strchr(s, ',')))
203     {
204         do
205         {
206             if ((eol = strchr(s, ',')))
207                 *eol++ = '\0';
208             if (sp->uid  == -1 && strncmp(s, "user=",  5) == 0)
209             {
210                 char * arg = s + 5;
211                 if (strspn(arg, "0123456789") == strlen(arg))
212                 {
213                     sp->uid = atoi(arg);
214                 }
215                 else
216                 {
217                     struct passwd * pw = getpwnam(arg);
218                     if(pw == NULL)
219                     {
220                         printf("No such user\n");
221                         return 0;
222                     }
223                     sp->uid = pw->pw_uid;
224                 }
225             }
226             else if (sp->gid == -1 && strncmp(s, "group=", 6) == 0)
227             {
228                 char * arg = s + 6;
229                 if (strspn(arg, "0123456789") == strlen(arg))
230                 {
231                     sp->gid = atoi(arg);
232                 }
233                 else
234                 {
235                     struct group * gr = getgrnam(arg);
236                     if (gr == NULL)
237                     {
238                         printf("No such group\n");
239                         return 0;
240                     }
241                     sp->gid = gr->gr_gid;
242                 }
243             }
244             else if (sp->umask == -1 && strncmp(s, "umask=", 6) == 0)
245             {
246                 char * end;
247                 char * arg = s + 6;
248                 
249                 sp->umask = strtol(arg, &end, 8);
250                 if (errno == EINVAL ||
251                     *end)
252                 {
253                     printf("Invalid umask\n");
254                     return 0;
255                 }
256             }
257             else if (file == NULL && strncmp(s, "file=", 5) == 0)
258             {
259                 char * arg = s + 5;
260                 file = arg;
261             }
262             else
263             {
264                 printf("invalid or double argument: %s\n", s);
265                 return 0;
266             }
267         } while((s = eol));
268     }
269     else
270     {
271         file = str;
272     }
273     if(! file)
274     {
275         errno = EINVAL;
276         return 0;
277     }
278
279     TRC(fprintf(stderr, "unix_straddr: %s\n", str ? str : "NULL"));
280
281     if (!unix_strtoaddr_ex (file, &sp->addr))
282         return 0;
283     return &sp->addr;
284 }
285
286 static void *unix_straddr(COMSTACK h, const char *str)
287 {
288     char *f = xstrdup(str);
289     void *vp = unix_straddr1(h, str, f);
290     xfree(f);
291     return vp;
292 }
293
294 struct sockaddr_un *unix_strtoaddr(const char *str)
295 {
296     static struct sockaddr_un add;
297
298     TRC(fprintf(stderr, "unix_strtoaddr: %s\n", str ? str : "NULL"));
299
300     if (!unix_strtoaddr_ex (str, &add))
301         return 0;
302     return &add;
303 }
304
305 static int unix_more(COMSTACK h)
306 {
307     unix_state *sp = (unix_state *)h->cprivate;
308
309     return sp->altlen && (*sp->complete)(sp->altbuf, sp->altlen);
310 }
311
312 /*
313  * connect(2) will block (sometimes) - nothing we can do short of doing
314  * weird things like spawning subprocesses or threading or some weird junk
315  * like that.
316  */
317 static int unix_connect(COMSTACK h, void *address)
318 {
319     struct sockaddr_un *add = (struct sockaddr_un *)address;
320     int r;
321     int i;
322
323     TRC(fprintf(stderr, "unix_connect\n"));
324     h->io_pending = 0;
325     if (h->state != CS_ST_UNBND)
326     {
327         h->cerrno = CSOUTSTATE;
328         return -1;
329     }
330     for (i = 0; i<3; i++)
331     {
332         r = connect(h->iofile, (struct sockaddr *) add, SUN_LEN(add));
333         if (r < 0 && yaz_errno() == EAGAIN)
334         {
335 #if HAVE_USLEEP
336             usleep(i*10000+1000); /* 1ms, 11ms, 21ms */
337 #else
338             sleep(1);
339 #endif
340             continue;
341         }
342         else
343             break;
344     }
345     if (r < 0)
346     {
347         if (yaz_errno() == EINPROGRESS)
348         {
349             h->event = CS_CONNECT;
350             h->state = CS_ST_CONNECTING;
351             h->io_pending = CS_WANT_WRITE;
352             return 1;
353         }
354         h->cerrno = CSYSERR;
355         return -1;
356     }
357     h->event = CS_CONNECT;
358     h->state = CS_ST_CONNECTING;
359
360     return unix_rcvconnect (h);
361 }
362
363 /*
364  * nop
365  */
366 static int unix_rcvconnect(COMSTACK h)
367 {
368     TRC(fprintf(stderr, "unix_rcvconnect\n"));
369
370     if (h->state == CS_ST_DATAXFER)
371         return 0;
372     if (h->state != CS_ST_CONNECTING)
373     {
374         h->cerrno = CSOUTSTATE;
375         return -1;
376     }
377     h->event = CS_DATA;
378     h->state = CS_ST_DATAXFER;
379     return 0;
380 }
381
382 static int unix_bind(COMSTACK h, void *address, int mode)
383 {
384     unix_state *sp = (unix_state *)h->cprivate;
385     struct sockaddr *addr = (struct sockaddr *)address;
386     const char * path = ((struct sockaddr_un *)addr)->sun_path;
387     struct stat stat_buf;
388
389     TRC (fprintf (stderr, "unix_bind\n"));
390
391     if(stat(path, &stat_buf) != -1) {
392         struct sockaddr_un socket_unix;
393         int socket_out = -1;
394
395         if((stat_buf.st_mode&S_IFMT) != S_IFSOCK) { /* used to be S_ISSOCK */
396             h->cerrno = CSYSERR;
397             yaz_set_errno(EEXIST); /* Not a socket (File exists) */
398             return -1;
399         }
400         if((socket_out = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
401             h->cerrno = CSYSERR;
402             return -1;
403         }
404         socket_unix.sun_family = AF_UNIX;
405         strncpy(socket_unix.sun_path, path, sizeof(socket_unix.sun_path)-1);
406         socket_unix.sun_path[sizeof(socket_unix.sun_path)-1] = 0;
407         if(connect(socket_out, (struct sockaddr *) &socket_unix, SUN_LEN(&socket_unix)) < 0) {
408             if(yaz_errno() == ECONNREFUSED) {
409                 TRC (fprintf (stderr, "Socket exists but nobody is listening\n"));
410             } else {
411                 h->cerrno = CSYSERR;
412                 return -1;
413             }
414         } else {
415             close(socket_out);
416             h->cerrno = CSYSERR;
417             yaz_set_errno(EADDRINUSE);
418             return -1;
419         }
420         unlink(path);
421     }
422
423     if (bind(h->iofile, (struct sockaddr *) addr, SUN_LEN((struct sockaddr_un *)addr)))
424     {
425         h->cerrno = CSYSERR;
426         return -1;
427     }
428     chown(path, sp->uid, sp->gid);
429     chmod(path, sp->umask != -1 ? sp->umask : 0666);
430     if (mode == CS_SERVER && listen(h->iofile, 100) < 0)
431     {
432         h->cerrno = CSYSERR;
433         return -1;
434     }
435     h->state = CS_ST_IDLE;
436     h->event = CS_LISTEN;
437     return 0;
438 }
439
440 static int unix_listen(COMSTACK h, char *raddr, int *addrlen,
441                     int (*check_ip)(void *cd, const char *a, int len, int t),
442                     void *cd)
443 {
444     struct sockaddr_un addr;
445     YAZ_SOCKLEN_T len = sizeof(addr);
446
447     TRC(fprintf(stderr, "unix_listen pid=%d\n", getpid()));
448     if (h->state != CS_ST_IDLE)
449     {
450         h->cerrno = CSOUTSTATE;
451         return -1;
452     }
453     h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len);
454     if (h->newfd < 0)
455     {
456         if (
457             yaz_errno() == EWOULDBLOCK
458 #ifdef EAGAIN
459 #if EAGAIN != EWOULDBLOCK
460             || yaz_errno() == EAGAIN
461 #endif
462 #endif
463             )
464             h->cerrno = CSNODATA;
465         else
466             h->cerrno = CSYSERR;
467         return -1;
468     }
469     if (addrlen && (size_t) (*addrlen) >= sizeof(struct sockaddr_un))
470         memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_un));
471     else if (addrlen)
472         *addrlen = 0;
473     h->state = CS_ST_INCON;
474     return 0;
475 }
476
477 static COMSTACK unix_accept(COMSTACK h)
478 {
479     COMSTACK cnew;
480     unix_state *state, *st = (unix_state *)h->cprivate;
481
482     TRC(fprintf(stderr, "unix_accept\n"));
483     if (h->state == CS_ST_INCON)
484     {
485         if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
486         {
487             h->cerrno = CSYSERR;
488             close(h->newfd);
489             h->newfd = -1;
490             return 0;
491         }
492         memcpy(cnew, h, sizeof(*h));
493         cnew->iofile = h->newfd;
494         cnew->io_pending = 0;
495         if (!(state = (unix_state *)
496               (cnew->cprivate = xmalloc(sizeof(unix_state)))))
497         {
498             h->cerrno = CSYSERR;
499             if (h->newfd != -1)
500             {
501                 close(h->newfd);
502                 h->newfd = -1;
503             }
504             return 0;
505         }
506         if (!(cnew->flags&CS_FLAGS_BLOCKING) && 
507             (fcntl(cnew->iofile, F_SETFL, O_NONBLOCK) < 0)
508             )
509         {
510             h->cerrno = CSYSERR;
511             if (h->newfd != -1)
512             {
513                 close(h->newfd);
514                 h->newfd = -1;
515             }
516             xfree (cnew);
517             xfree (state);
518             return 0;
519         }
520         h->newfd = -1;
521         state->altbuf = 0;
522         state->altsize = state->altlen = 0;
523         state->towrite = state->written = -1;
524         state->complete = st->complete;
525         memcpy(&state->addr, &st->addr, sizeof(state->addr));
526         cnew->state = CS_ST_ACCEPT;
527         cnew->event = CS_NONE;
528         h->state = CS_ST_IDLE;
529
530         h = cnew;
531     }
532     if (h->state == CS_ST_ACCEPT)
533     {
534     }
535     else
536     {
537         h->cerrno = CSOUTSTATE;
538         return 0;
539     }
540     h->io_pending = 0;
541     h->state = CS_ST_DATAXFER;
542     h->event = CS_DATA;
543     return h;
544 }
545
546 #define CS_UNIX_BUFCHUNK 4096
547
548 /*
549  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
550  * 0=connection closed.
551  */
552 static int unix_get(COMSTACK h, char **buf, int *bufsize)
553 {
554     unix_state *sp = (unix_state *)h->cprivate;
555     char *tmpc;
556     int tmpi, berlen, rest, req, tomove;
557     int hasread = 0, res;
558
559     TRC(fprintf(stderr, "unix_get: bufsize=%d\n", *bufsize));
560     if (sp->altlen) /* switch buffers */
561     {
562         TRC(fprintf(stderr, "  %d bytes in altbuf (0x%x)\n", sp->altlen,
563                     (unsigned) sp->altbuf));
564         tmpc = *buf;
565         tmpi = *bufsize;
566         *buf = sp->altbuf;
567         *bufsize = sp->altsize;
568         hasread = sp->altlen;
569         sp->altlen = 0;
570         sp->altbuf = tmpc;
571         sp->altsize = tmpi;
572     }
573     h->io_pending = 0;
574     while (!(berlen = (*sp->complete)(*buf, hasread)))
575     {
576         if (!*bufsize)
577         {
578             if (!(*buf = (char *)xmalloc(*bufsize = CS_UNIX_BUFCHUNK)))
579                 return -1;
580         }
581         else if (*bufsize - hasread < CS_UNIX_BUFCHUNK)
582             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
583                 return -1;
584         res = recv(h->iofile, *buf + hasread, CS_UNIX_BUFCHUNK, 0);
585         TRC(fprintf(stderr, "  recv res=%d, hasread=%d\n", res, hasread));
586         if (res < 0)
587         {
588             if (yaz_errno() == EWOULDBLOCK
589 #ifdef EAGAIN
590 #if EAGAIN != EWOULDBLOCK
591                 || yaz_errno() == EAGAIN
592 #endif
593 #endif
594                 || yaz_errno() == EINPROGRESS
595                 )
596             {
597                 h->io_pending = CS_WANT_READ;
598                 break;
599             }
600             else if (yaz_errno() == 0)
601                 continue;
602             else
603                 return -1;
604         }
605         else if (!res)
606             return hasread;
607         hasread += res;
608     }
609     TRC (fprintf (stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
610                   hasread, berlen));
611     /* move surplus buffer (or everything if we didn't get a BER rec.) */
612     if (hasread > berlen)
613     {
614         tomove = req = hasread - berlen;
615         rest = tomove % CS_UNIX_BUFCHUNK;
616         if (rest)
617             req += CS_UNIX_BUFCHUNK - rest;
618         if (!sp->altbuf)
619         {
620             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
621                 return -1;
622         } else if (sp->altsize < req)
623             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
624                 return -1;
625         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(0x%x)\n", tomove,
626                     (unsigned) sp->altbuf));
627         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
628     }
629     if (berlen < CS_UNIX_BUFCHUNK - 1)
630         *(*buf + berlen) = '\0';
631     return berlen ? berlen : 1;
632 }
633
634
635
636 /*
637  * Returns 1, 0 or -1
638  * In nonblocking mode, you must call again with same buffer while
639  * return value is 1.
640  */
641 static int unix_put(COMSTACK h, char *buf, int size)
642 {
643     int res;
644     struct unix_state *state = (struct unix_state *)h->cprivate;
645
646     TRC(fprintf(stderr, "unix_put: size=%d\n", size));
647     h->io_pending = 0;
648     h->event = CS_DATA;
649     if (state->towrite < 0)
650     {
651         state->towrite = size;
652         state->written = 0;
653     }
654     else if (state->towrite != size)
655     {
656         h->cerrno = CSWRONGBUF;
657         return -1;
658     }
659     while (state->towrite > state->written)
660     {
661         if ((res =
662              send(h->iofile, buf + state->written, size -
663                   state->written,
664 #ifdef MSG_NOSIGNAL
665                   MSG_NOSIGNAL
666 #else
667                   0
668 #endif
669                  )) < 0)
670         {
671             if (
672                 yaz_errno() == EWOULDBLOCK
673 #ifdef EAGAIN
674 #if EAGAIN != EWOULDBLOCK
675                 || yaz_errno() == EAGAIN
676 #endif
677 #endif
678                 )
679             {
680                 TRC(fprintf(stderr, "  Flow control stop\n"));
681                 h->io_pending = CS_WANT_WRITE;
682                 return 1;
683             }
684             h->cerrno = CSYSERR;
685             return -1;
686         }
687         state->written += res;
688         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
689                     res, state->written, size));
690     }
691     state->towrite = state->written = -1;
692     TRC(fprintf(stderr, "  Ok\n"));
693     return 0;
694 }
695
696 static int unix_close(COMSTACK h)
697 {
698     unix_state *sp = (struct unix_state *)h->cprivate;
699
700     TRC(fprintf(stderr, "unix_close\n"));
701     if (h->iofile != -1)
702     {
703         close(h->iofile);
704     }
705     if (sp->altbuf)
706         xfree(sp->altbuf);
707     xfree(sp);
708     xfree(h);
709     return 0;
710 }
711
712 static char *unix_addrstr(COMSTACK h)
713 {
714     unix_state *sp = (struct unix_state *)h->cprivate;
715     char *buf = sp->buf;
716     sprintf(buf, "unix:%s", sp->addr.sun_path);
717     return buf;
718 }
719
720 static int unix_set_blocking(COMSTACK p, int flags)
721 {
722     unsigned long flag;
723
724     if (p->flags == flags)
725         return 1;
726     flag = fcntl(p->iofile, F_GETFL, 0);
727     if (flags & CS_FLAGS_BLOCKING)
728         flag = flag & ~O_NONBLOCK;
729     else
730         flag = flag | O_NONBLOCK;
731     if (fcntl(p->iofile, F_SETFL, flag) < 0)
732         return 0;
733     p->flags = flags;
734     return 1;
735 }
736 #endif /* WIN32 */
737 /*
738  * Local variables:
739  * c-basic-offset: 4
740  * indent-tabs-mode: nil
741  * End:
742  * vim: shiftwidth=4 tabstop=8 expandtab
743  */
744