comstack/xmosi.c

   1 /*
   2  * Copyright (c) 1995, Index Data
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: xmosi.c,v $
   7  * Revision 1.17  1999-06-16 11:55:24  adam
   8  * Added APDU log to client.
   9  *
  10  * Revision 1.16  1997/09/17 12:10:30  adam
  11  * YAZ version 1.4.
  12  *
  13  * Revision 1.15  1997/05/14 06:53:34  adam
  14  * C++ support.
  15  *
  16  * Revision 1.14  1996/07/26 12:34:07  quinn
  17  * Porting.
  18  *
  19  * Revision 1.13  1996/07/06  19:58:30  quinn
  20  * System headerfiles gathered in yconfig
  21  *
  22  * Revision 1.12  1996/05/22  08:34:44  adam
  23  * Added ifdef USE_XTIMOSI; so that 'make depend' works.
  24  *
  25  * Revision 1.11  1996/02/23 10:00:41  quinn
  26  * WAIS Work
  27  *
  28  * Revision 1.10  1996/02/10  12:23:13  quinn
  29  * Enablie inetd operations fro TCP/IP stack
  30  *
  31  * Revision 1.9  1996/01/02  08:57:28  quinn
  32  * Changed enums in the ASN.1 .h files to #defines. Changed oident.class to oclass
  33  *
  34  * Revision 1.8  1995/11/01  13:54:29  quinn
  35  * Minor adjustments
  36  *
  37  * Revision 1.7  1995/10/30  12:41:17  quinn
  38  * Added hostname lookup for server.
  39  *
  40  * Revision 1.6  1995/09/29  17:12:00  quinn
  41  * Smallish
  42  *
  43  * Revision 1.5  1995/09/28  10:24:32  quinn
  44  * Windows changes
  45  *
  46  * Revision 1.4  1995/09/27  15:02:45  quinn
  47  * Modified function heads & prototypes.
  48  *
  49  * Revision 1.3  1995/06/16  10:30:38  quinn
  50  * Added REUSEADDR.
  51  *
  52  * Revision 1.2  1995/06/15  12:30:07  quinn
  53  * Added @ as hostname alias for INADDR ANY.
  54  *
  55  * Revision 1.1  1995/06/14  09:58:20  quinn
  56  * Renamed yazlib to comstack.
  57  *
  58  * Revision 1.15  1995/05/29  08:12:33  quinn
  59  * Updates to aynch. operations.
  60  *
  61  * Revision 1.14  1995/05/16  09:37:31  quinn
  62  * Fixed bug
  63  *
  64  * Revision 1.13  1995/05/16  08:51:19  quinn
  65  * License, documentation, and memory fixes
  66  *
  67  * Revision 1.12  1995/05/02  08:53:24  quinn
  68  * Trying in vain to fix comm with ISODE
  69  *
  70  * Revision 1.11  1995/04/21  16:32:08  quinn
  71  * *** empty log message ***
  72  *
  73  * Revision 1.10  1995/03/27  08:36:14  quinn
  74  * Some work on nonblocking operation in xmosi.c and rfct.c.
  75  * Added protocol parameter to cs_create()
  76  *
  77  * Revision 1.9  1995/03/20  09:47:23  quinn
  78  * Added server-side support to xmosi.c
  79  * Fixed possible problems in rfct
  80  * Other little mods
  81  *
  82  * Revision 1.8  1995/03/16  13:29:30  quinn
  83  * Beginning to add server-side functions
  84  *
  85  * Revision 1.7  1995/03/14  10:28:47  quinn
  86  * Adding server-side support to tcpip.c and fixing bugs in nonblocking I/O
  87  *
  88  * Revision 1.6  1995/03/09  15:22:43  quinn
  89  * Fixed two bugs in get/rcv
  90  *
  91  * Revision 1.5  1995/03/07  16:29:47  quinn
  92  * Various fixes.
  93  *
  94  * Revision 1.4  1995/03/07  10:26:56  quinn
  95  * Initialized type field in the comstacks.
  96  *
  97  * Revision 1.3  1995/03/06  16:48:03  quinn
  98  * Smallish changes.
  99  *
 100  * Revision 1.2  1995/03/06  10:54:41  quinn
 101  * Server-side functions (t_bind/t_listen/t_accept) seem to work ok, now.
 102  * Nonblocking mode needs work (and testing!)
 103  * Added makensap to replace function in mosiutil.c.
 104  *
 105  * Revision 1.1  1995/03/01  08:40:33  quinn
 106  * First working version of rfct. Addressing needs work.
 107  *
 108  */
 109
 110 #ifdef USE_XTIMOSI
 111 /*
 112  * Glue layer for Peter Furniss' xtimosi package.
 113  */
 114
 115 #include <fcntl.h>
 116 #include <stdlib.h>
 117 #include <string.h>
 118 #include <assert.h>
 119
 120 #define YNETINCLUDE
 121 #include <yconfig.h>
 122
 123 #include <comstack.h>
 124 #include <xmosi.h>
 125
 126 #include <oid.h>
 127
 128 int mosi_connect(COMSTACK h, void *address);
 129 int mosi_get(COMSTACK h, char **buf, int *bufsize);
 130 int mosi_put(COMSTACK h, char *buf, int size);
 131 int mosi_more(COMSTACK h) { return 0; } /* not correct */
 132 int mosi_close(COMSTACK h);
 133 int mosi_rcvconnect(COMSTACK h);
 134 int mosi_bind(COMSTACK h, void *address, int mode);
 135 int mosi_listen(COMSTACK h, char *addrp, int *addrlen);
 136 COMSTACK mosi_accept(COMSTACK h);
 137 char *mosi_addrstr(COMSTACK h);
 138 void *mosi_straddr(COMSTACK h, const char *str);
 139
 140 typedef struct mosi_state
 141 {
 142     struct t_info info;        /* data returned by t_open */
 143     struct t_call *call;
 144     int hasread;               /* how many bytes read of current PDU */
 145     int haswrit;               /* how many bytes have we written */
 146     struct netbuf netbuf;
 147 } mosi_state;
 148
 149 static char *oidtostr(int *o)
 150 {
 151     static char buf[512];
 152
 153     buf[0] = '\0';
 154     while (*o >= 0)
 155     {
 156         sprintf(buf + strlen(buf), "%d", *o);
 157         if (*(++o) >= 0)
 158             strcat(buf, " ");
 159     }
 160     return buf;
 161 }
 162
 163 static int addopt(struct netbuf *optbuf, unsigned long level, unsigned long
 164     name, enum oid_proto proto, enum oid_class class, enum oid_value value)
 165 {
 166     int *oid;
 167     oident ent;
 168     char *str;
 169
 170     ent.proto = proto;
 171     ent.oclass = class;
 172     ent.value = value;
 173     if (!(oid = oid_getoidbyent(&ent)))
 174         return -1;
 175     str = oidtostr(oid);
 176     if (addoidoption(optbuf, level, name, str) < 0)
 177         return -1;
 178     return 0;
 179 }
 180
 181 COMSTACK mosi_type(int s, int blocking, int protocol)
 182 {
 183     COMSTACK r;
 184     mosi_state *state;
 185     int flags = O_RDWR;
 186
 187     if (s >= 0)
 188         return 0;
 189
 190     if (!(r = xmalloc(sizeof(*r))))
 191         return 0;
 192     if (!(state = r->cprivate = xmalloc(sizeof(*state))))
 193         return 0;
 194
 195     state->call = 0;
 196     state->hasread = 0;
 197     state->haswrit = 0;
 198     r->protocol = protocol;
 199     r->state = CS_UNBND;
 200     r->type = mosi_type;
 201     r->blocking = blocking;
 202     r->f_connect = mosi_connect;
 203     r->f_put = mosi_put;
 204     r->f_get = mosi_get;
 205     r->f_close = mosi_close;
 206     r->f_more = mosi_more;
 207     r->f_rcvconnect = mosi_rcvconnect;
 208     r->f_bind = mosi_bind;
 209     r->f_listen = mosi_listen;
 210     r->f_accept = mosi_accept;
 211     r->f_addrstr = mosi_addrstr;
 212     r->r_straddr = mosi_straddr;
 213
 214     if (!blocking)
 215         flags |= O_NONBLOCK;
 216     if ((r->iofile = u_open(CO_MOSI_NAME, flags, &state->info)) < 0)
 217         return 0;
 218
 219     r->timeout = COMSTACK_DEFAULT_TIMEOUT;
 220
 221     return r;
 222 }
 223
 224 int hex2oct(char *hex, char *oct)
 225 {
 226     int len = 0;
 227     unsigned val;
 228
 229     while (sscanf(hex, "%2x", &val) == 1)
 230     {
 231         if (strlen(hex) < 2)
 232             return -1;
 233         *((unsigned char*) oct++) = (unsigned char) val;
 234         len++;
 235         hex += 2;
 236     }
 237     return len;
 238 }
 239
 240 /*
 241  * addressing specific to our hack of OSI transport. A sockaddr_in wrapped
 242  * up in a t_mosiaddr in a netbuf (on a stick).
 243  */
 244
 245 int *mosi_strtoaddr_ex(const char *str, struct netbuf *ret)
 246 {
 247     struct sockaddr_in *add = xmalloc(sizeof(struct sockaddr_in));
 248     struct t_mosiaddr *mosiaddr = xmalloc(sizeof(struct t_mosiaddr));
 249     struct hostent *hp;
 250     char *p, *b, buf[512], *nsap;
 251     short int port = 102;
 252     unsigned long tmpadd;
 253     int ll = 0;
 254
 255     assert(ret && add && mosiaddr);
 256 #if 0
 257     mosiaddr->osi_ap_inv_id = NO_INVOKEID;
 258     mosiaddr->osi_ae_inv_id = NO_INVOKEID;
 259 #endif
 260     mosiaddr->osi_apt_len = 0;
 261     mosiaddr->osi_aeq_len = 0;
 262     p = (char*)MOSI_PADDR(mosiaddr);
 263     *(p++) = 0; /* No presentation selector */
 264     ll++;
 265     *(p++) = 0; /* no session selector */
 266     ll++;
 267     /* do we have a transport selector? */
 268     strcpy(buf, str);
 269     if ((nsap = strchr(buf, '/')))
 270     {
 271         *(nsap++) = '\0';
 272         if ((*p = hex2oct(buf, p + 1)) < 0)
 273             return 0;
 274         ll += *p + 1;
 275         p += *p + 1;
 276     }
 277     else
 278     {
 279         nsap = buf;
 280         *(p++) = 0;
 281         ll++;
 282     }
 283     if (nsap && *nsap)
 284     {
 285         add->sin_family = AF_INET;
 286         strcpy(buf, nsap);
 287         if ((b = strchr(buf, ':')))
 288         {
 289             *b = 0;
 290             port = atoi(b + 1);
 291         }
 292         add->sin_port = htons(port);
 293         if (!strcmp("@", buf))
 294             add->sin_addr.s_addr = INADDR_ANY;
 295         else if ((hp = gethostbyname(buf)))
 296             memcpy(&add->sin_addr.s_addr, *hp->h_addr_list, sizeof(struct in_addr));
 297         else if ((tmpadd = inet_addr(buf)) != 0)
 298             memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
 299         else
 300             return 0;
 301         *(p++) = (char) sizeof(*add);
 302         ll++;
 303         memcpy(p, add, sizeof(*add));
 304         ll += sizeof(*add);
 305     }
 306     else
 307     {
 308         *(p++) = 0;
 309         ll++;
 310     }
 311     mosiaddr->osi_paddr_len = ll;
 312     ret->buf = (char*)mosiaddr;
 313     ret->len = ret->maxlen = 100 /* sizeof(*mosiaddr) */ ;
 314
 315     return 1;
 316 }
 317
 318 struct netbuf *mosi_strtoaddr(const char *str)
 319 {
 320     struct netbuf *ret = xmalloc(sizeof(struct netbuf));
 321
 322     if (!mosi_strtoaddr_ex (str, ret))
 323     {
 324         xfree (ret);
 325         return 0;
 326     }
 327     return ret;
 328 }
 329
 330 struct netbuf *mosi_straddr(COMSTACK h, const char *str)
 331 {
 332     mosi_state *st = h->cprivate;
 333     struct netbuf *ret = &st->netbuf;
 334
 335     if (!mosi_strtoaddr_ex (str, ret))
 336     {
 337         xfree (ret);
 338         return 0;
 339     }
 340     return ret;
 341 }
 342
 343 int mosi_connect(COMSTACK h, void *address)
 344 {
 345     struct netbuf *addr = address, *local;
 346     struct t_call *snd, *rcv;
 347     struct t_bind bnd;
 348
 349     if (!(snd = (struct t_call *) u_alloc(h->iofile, T_CALL, T_ALL)))
 350         return -1;
 351     if (!(rcv = (struct t_call *) u_alloc(h->iofile, T_CALL, T_ALL)))
 352         return -1;
 353
 354     snd->udata.len = 0;
 355     if (addopt(&snd->opt, ISO_APCO, AP_CNTX_NAME, h->protocol, CLASS_APPCTX,
 356         VAL_BASIC_CTX) < 0)
 357         return -1;
 358     if (addopt(&snd->opt, ISO_APCO, AP_ABS_SYN, h->protocol, CLASS_ABSYN,
 359         VAL_APDU) < 0)
 360         return -1;
 361     /*
 362      * We don't specify record formats yet.
 363      *
 364      * Xtimosi adds the oid for BER as transfer syntax automatically.
 365      */
 366
 367     bnd.qlen = 0;
 368
 369     if (h->state == CS_UNBND)
 370     {
 371         local = mosi_strtoaddr("");   /* not good in long run */
 372         memcpy(&bnd.addr, local, sizeof(*local));
 373         if (u_bind(h->iofile, &bnd, 0) < 0)
 374             return -1;
 375     }
 376
 377     memcpy(&snd->addr, addr, sizeof(*addr));
 378     if (u_connect(h->iofile, snd, rcv) < 0)
 379     {
 380         if (t_errno == TNODATA)
 381             return 1;
 382         return -1;
 383     }
 384     return 0;
 385 }
 386
 387 int mosi_rcvconnect(COMSTACK h)
 388 {
 389     if (u_rcvconnect(h->iofile, 0) < 0)
 390     {
 391         if (t_errno == TNODATA)
 392             return 1;
 393         return -1;
 394     }
 395     return 0;
 396 }
 397
 398 int mosi_bind(COMSTACK h, void *address, int mode)
 399 {
 400     int res;
 401     struct t_bind bnd;
 402     int one = 1;
 403
 404     if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0)
 405     {
 406         h->cerrno = CSYSERR;
 407         return -1;
 408     }
 409     if (mode == CS_SERVER)
 410         bnd.qlen = 3;
 411     else
 412         bnd.qlen = 0;
 413     memcpy(&bnd.addr, address, sizeof(struct netbuf));
 414     if ((res = u_bind(h->iofile, &bnd, 0)) < 0)
 415         return -1;
 416     h->state = CS_IDLE;
 417     return 0;
 418 }
 419
 420 int mosi_listen(COMSTACK h, char *addp, int *addrlen)
 421 {
 422     int res;
 423     mosi_state *st = h->cprivate;
 424
 425     if (!(st->call = (struct t_call*) t_alloc(h->iofile, T_CALL_STR,
 426          T_ALL)))
 427         return -1;
 428     if ((res = u_listen(h->iofile, st->call)) < 0)
 429     {
 430         if (t_errno == TNODATA)
 431             return 1;
 432         return -1;
 433     }
 434     h->state = CS_INCON;
 435     return 0;
 436 }
 437
 438 COMSTACK mosi_accept(COMSTACK h)
 439 {
 440     COMSTACK new;
 441     void *local;
 442     struct mosi_state *st = h->cprivate, *ns;
 443     int flags = O_RDWR;
 444
 445     if (h->state != CS_INCON)
 446     {
 447         h->cerrno = CSOUTSTATE;
 448         return 0;
 449     }
 450     if (!(new = xmalloc(sizeof(*new))))
 451         return 0;
 452     *new = *h;
 453     if (!(new->cprivate = ns = xmalloc(sizeof(*ns))))
 454         return 0;
 455     *ns = *st;
 456     if (!h->blocking)
 457         flags |= O_NONBLOCK;
 458     if ((new->iofile = u_open_r(CO_MOSI_NAME, flags, &st->info, st->call)) < 0)
 459         return 0;
 460     if (!(local = mosi_strtoaddr("")))
 461         return 0;
 462     if (mosi_bind(new, local, CS_CLIENT) < 0) /* CS_CLIENT: qlen == 0 */
 463         return 0;
 464     memcpy(&st->call->addr, local, sizeof(st->call->addr));
 465     if (u_accept(h->iofile, new->iofile, st->call) < 0)
 466     {
 467         mosi_close(new);
 468         return 0;
 469     }
 470     return new;
 471 }
 472
 473 #define CS_MOSI_BUFCHUNK 4096
 474
 475 int mosi_get(COMSTACK h, char **buf, int *bufsize)
 476 {
 477     int flags = 0, res;
 478     mosi_state *ct = h->cprivate;
 479     int got;
 480
 481     do
 482     {
 483         if (!*bufsize)
 484         {
 485             if (!(*buf = xmalloc(*bufsize = CS_MOSI_BUFCHUNK)))
 486                 return -1;
 487         }
 488         else if (*bufsize - ct->hasread < CS_MOSI_BUFCHUNK)
 489             if (!(*buf =xrealloc(*buf, *bufsize *= 2)))
 490                 return -1;
 491
 492         if ((res = u_rcv(h->iofile, *buf + ct->hasread, CS_MOSI_BUFCHUNK,
 493             &flags)) <= 0)
 494         {
 495             if (t_errno == TNODATA)
 496                 return 1;
 497             return -1;
 498         }
 499         ct->hasread += res;
 500     }
 501     while (flags & T_MORE);
 502
 503     /* all done. Reset hasread */
 504     got = ct->hasread;
 505     ct->hasread = 0;
 506     return got;
 507 }
 508
 509 int mosi_put(COMSTACK h, char *buf, int size)
 510 {
 511     mosi_state *ct = h->cprivate;
 512     int res = u_snd(h->iofile, buf + ct->haswrit, size - ct->haswrit, 0);
 513
 514     if (res == size - ct->haswrit)
 515     {
 516         ct->haswrit = 0;
 517         return 0;
 518     }
 519     else if (res < 0)
 520     {
 521         if (t_errno == TFLOW)
 522             return 1;
 523         return -1;
 524     }
 525     ct->haswrit += res;
 526     return 1;
 527 }
 528
 529 int mosi_close(COMSTACK h)
 530 {
 531     xfree(h->cprivate);
 532     if (h->iofile >= 0)
 533         u_close(h->iofile);
 534    xfree(h);
 535     return 0;
 536 }
 537
 538 char *mosi_addrstr(COMSTACK h)
 539 {
 540     return "osi:[UNIMPLEMENTED]";
 541 }
 542
 543 #endif