comstack/unix.c

   1 /*
   2  * Copyright (c) 1995-2002, Index Data
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: unix.c,v 1.8 2002-12-15 21:22:58 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