usr/src/cmd/bnu/interface.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2014 Gary Mills
  24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  29 /*        All Rights Reserved   */
  30
  31 /*
  32  *      interface(label)
  33  *      provide alternate definitions for the I/O functions through global
  34  *      interfaces.
  35  */
  36 #include        "uucp.h"
  37
  38 #ifdef TLI
  39 #include        <tiuser.h>
  40 char *t_alloc();
  41 int t_bind(), t_close(), t_connect(), t_free(), t_look(), t_open(), t_rcvdis();
  42 int t_getinfo(), t_getstate(), t_look(), t_rcv(), t_snd(), t_sync(), t_unbind();
  43 #endif /*  TLI  */
  44
  45 #ifdef DATAKIT
  46 #include        "dk.h"
  47
  48 static int      dksetup();
  49 static int      dkteardown();
  50 #endif  /* DATAKIT */
  51
  52 EXTERN void     sethup();
  53 EXTERN int      restline();
  54 #if defined(__STDC__)
  55 extern int      ioctl(int, int, ...);
  56 #else
  57 extern int      ioctl();
  58 #endif
  59 static int      usetup(), uteardown();
  60
  61 GLOBAL ssize_t  (*Read)() = read,
  62         (*Write)() = write;
  63 #if defined(__STDC__)
  64 GLOBAL int      (*Ioctl)(int, int, ...) = ioctl,
  65 #else
  66 GLOBAL int      (*Ioctl)() = ioctl,
  67 #endif
  68         (*Setup)() = usetup,
  69         (*Teardown)() = uteardown;
  70
  71 #ifdef TLI
  72 EXTERN void tfaillog(), show_tlook();
  73 static ssize_t  tread(), twrite();      /* TLI i/o */
  74 #ifdef __STDC__
  75 static int      tioctl(int, int, ...),
  76 #else
  77 static int      tioctl(),               /* TLI i/o control */
  78 #endif
  79                 tsetup(),       /* TLI setup without streams module */
  80                 tssetup(),      /* TLI setup with streams module */
  81                 tteardown();    /* TLI teardown, works with either setup */
  82 #endif /*  TLI  */
  83 /*
  84  *      The IN_label in Interface[] imply different caller routines:
  85  *      e.g. tlicall().
  86  *      If so, the names here and the names in callers.c must match.
  87  */
  88
  89 static
  90 struct Interface {
  91         char    *IN_label;              /* interface name */
  92         ssize_t (*IN_read)();           /* read function */
  93         ssize_t (*IN_write)();          /* write function */
  94 #ifdef __STDC__
  95         int     (*IN_ioctl)(int, int, ...);
  96 #else
  97         int     (*IN_ioctl)();          /* ioctl function */
  98 #endif
  99         int     (*IN_setup)();          /* setup function, called before */
 100                                         /* first i/o operation */
 101         int     (*IN_teardown)();       /* teardown function, called after */
 102                                         /* last i/o operation */
 103 } Interface[] = {
 104                         /* vanilla UNIX */
 105                 { "UNIX", read, write, ioctl, usetup, uteardown },
 106 #ifdef TCP
 107                         /* TCP over sockets or UNET */
 108                 { "TCP", read, write, ioctl, usetup, uteardown },
 109 #endif /* TCP */
 110 #ifdef SYTEK
 111                         /* Sytek network */
 112                 { "Sytek", read, write, ioctl, usetup, uteardown },
 113 #endif /* Sytek network */
 114 #ifdef DIAL801
 115                         /* 801 auto dialers */
 116                 { "801", read, write, ioctl, usetup, uteardown },
 117 #endif /* DIAL801 */
 118 #ifdef DIAL801
 119                         /* 212 auto dialers */
 120                 { "212", read, write, ioctl, usetup, uteardown },
 121 #endif /* DIAL801 */
 122 #ifdef TLI
 123                         /* AT&T Transport Interface Library WITHOUT streams */
 124                 { "TLI", tread, twrite, tioctl, tsetup, tteardown },
 125 #ifdef TLIS
 126                         /* AT&T Transport Interface Library WITH streams */
 127                 { "TLIS", read, write, tioctl, tssetup, uteardown },
 128 #endif /*  TLIS  */
 129 #endif /*  TLI  */
 130 #ifdef DATAKIT
 131                 { "DK", read, write, ioctl, dksetup, dkteardown },
 132 #endif /* DATAKIT */
 133 #ifdef UNET
 134                 { "Unetserver", read, write, ioctl, usetup, uteardown },
 135 #endif
 136                 { 0, 0, 0, 0, 0, 0 }
 137         };
 138
 139
 140 GLOBAL int
 141 interface(label)
 142 char    *label;
 143 {
 144         register int    i;
 145
 146         for (i = 0;  Interface[i].IN_label;  ++i) {
 147                 if (0 == strcmp(Interface[i].IN_label, label)) {
 148                         Read = Interface[i].IN_read;
 149                         Write = Interface[i].IN_write;
 150                         Ioctl = Interface[i].IN_ioctl;
 151                         Setup = Interface[i].IN_setup;
 152                         Teardown = Interface[i].IN_teardown;
 153                         DEBUG(5, "set interface %s\n", label);
 154                         return (0);
 155                 }
 156         }
 157         return (FAIL);
 158 }
 159
 160 /*
 161  *      usetup - vanilla unix setup routine
 162  */
 163 static int
 164 usetup(role, fdreadp, fdwritep)
 165 int     *fdreadp, *fdwritep;
 166 {
 167         if (role == SLAVE)
 168         {
 169                 *fdreadp = 0;
 170                 *fdwritep = 1;
 171                 /* 2 has been re-opened to RMTDEBUG in main() */
 172         }
 173         return (SUCCESS);
 174 }
 175
 176 /*
 177  *      uteardown - vanilla unix teardown routine
 178  */
 179 static int
 180 uteardown(role, fdread, fdwrite)
 181 {
 182         int ret;
 183         char *ttyn;
 184
 185         if (role == SLAVE) {
 186                 ret = restline();
 187                 DEBUG(4, "ret restline - %d\n", ret);
 188                 if (fdread != -1)
 189                         sethup(fdread);
 190         }
 191         if (fdread != -1) {
 192                 ttyn = ttyname(fdread);
 193                 if (ttyn != NULL && Dev_mode != 0)
 194                         chmod(ttyn, Dev_mode);  /* can fail, but who cares? */
 195                 (void) close(fdread);
 196                 (void) close(fdwrite);
 197         }
 198         return (SUCCESS);
 199 }
 200
 201 #ifdef DATAKIT
 202 /*
 203  *      dksetup - DATAKIT setup routine
 204  *
 205  * Put line in block mode.
 206  */
 207
 208 static int
 209 dksetup(role, fdreadp, fdwritep)
 210
 211 int     role;
 212 int     *fdreadp;
 213 int     *fdwritep;
 214
 215 {
 216         static short dkrmode[3] = { DKR_BLOCK | DKR_TIME, 0, 0 };
 217         int     ret;
 218
 219         (void) usetup(role, fdreadp, fdwritep);
 220         if ((ret = (*Ioctl)(*fdreadp, DIOCRMODE, dkrmode)) < 0) {
 221                 DEBUG(4, "dksetup: failed to set block mode. ret=%d,\n", ret);
 222                 DEBUG(4, "read fd=%d, ", *fdreadp);
 223                 DEBUG(4, "errno=%d\n", errno);
 224                 return (FAIL);
 225         }
 226         return (SUCCESS);
 227 }
 228
 229 /*
 230  *      dkteardown  -  DATAKIT teardown routine
 231  */
 232 static int
 233 dkteardown(role, fdread, fdwrite)
 234 int     role, fdread, fdwrite;
 235 {
 236         char    *ttyn;
 237
 238         if (role == MASTER) {
 239                 ttyn = ttyname(fdread);
 240                 if (ttyn != NULL && Dev_mode != 0)
 241                         chmod(ttyn, Dev_mode);  /* can fail, but who cares? */
 242         }
 243
 244         /*      must flush fd's for datakit     */
 245         /*      else close can hang             */
 246         if (ioctl(fdread, DIOCFLUSH, NULL) != 0)
 247                 DEBUG(4, "dkteardown: DIOCFLUSH of input fd %d failed",
 248                     fdread);
 249         if (ioctl(fdwrite, DIOCFLUSH, NULL) != 0)
 250                 DEBUG(4, "dkteardown: DIOCFLUSH of output fd %d failed",
 251                     fdwrite);
 252
 253         (void) close(fdread);
 254         (void) close(fdwrite);
 255         return (SUCCESS);
 256 }
 257 #endif /* DATAKIT */
 258
 259
 260 #ifdef TLI
 261 /*
 262  *      tread - tli read routine
 263  */
 264 static ssize_t
 265 tread(fd, buf, nbytes)
 266 int             fd;
 267 char            *buf;
 268 unsigned        nbytes;
 269 {
 270         int             rcvflags;
 271
 272         return ((ssize_t)t_rcv(fd, buf, nbytes, &rcvflags));
 273 }
 274
 275 /*
 276  *      twrite - tli write routine
 277  */
 278 #define N_CHECK 100
 279 static ssize_t
 280 twrite(fd, buf, nbytes)
 281 int             fd;
 282 char            *buf;
 283 unsigned        nbytes;
 284 {
 285         register int            i, ret;
 286         static int              n_writ, got_info;
 287         static struct t_info    info;
 288
 289         if (got_info == 0) {
 290                 if (t_getinfo(fd, &info) != 0) {
 291                         tfaillog(fd, "twrite: t_getinfo\n");
 292                         return (FAIL);
 293                 }
 294                 got_info = 1;
 295         }
 296
 297         /* on every N_CHECKth call, check that are still in DATAXFER state */
 298         if (++n_writ == N_CHECK) {
 299                 n_writ = 0;
 300                 if (t_getstate(fd) != T_DATAXFER)
 301                         return (FAIL);
 302         }
 303
 304         if (info.tsdu <= 0 || nbytes <= info.tsdu)
 305                 return (t_snd(fd, buf, nbytes, NULL));
 306
 307         /* if get here, then there is a limit on transmit size  */
 308         /* (info.tsdu > 0) and buf exceeds it                   */
 309         i = ret = 0;
 310         while (nbytes >= info.tsdu) {
 311                 if ((ret = t_snd(fd,  &buf[i], info.tsdu, NULL)) != info.tsdu)
 312                         return ((ret >= 0 ? (i + ret) : ret));
 313                 i += info.tsdu;
 314                 nbytes -= info.tsdu;
 315         }
 316         if (nbytes != 0) {
 317                 if ((ret = t_snd(fd,  &buf[i], nbytes, NULL)) != nbytes)
 318                         return ((ssize_t)(ret >= 0 ? (i + ret) : ret));
 319                 i += nbytes;
 320         }
 321         return ((ssize_t)i);
 322 }
 323
 324
 325 /*
 326  *      tioctl - stub for tli ioctl routine
 327  */
 328 /*ARGSUSED*/
 329 static int
 330 #ifdef __STDC__
 331 tioctl(int fd, int request, ...)
 332 #else
 333 tioctl(fd, request, arg)
 334 int     fd, request;
 335 #endif
 336 {
 337         return (SUCCESS);
 338 }
 339
 340 /*
 341  *      tsetup - tli setup routine
 342  *      note blatant assumption that *fdreadp == *fdwritep == 0
 343  */
 344 static int
 345 tsetup(role, fdreadp, fdwritep)
 346 int     *fdreadp, *fdwritep;
 347 {
 348
 349         if (role == SLAVE) {
 350                 *fdreadp = 0;
 351                 *fdwritep = 1;
 352                 /* 2 has been re-opened to RMTDEBUG in main() */
 353                 errno = t_errno = 0;
 354                 if (t_sync(*fdreadp) == -1 || t_sync(*fdwritep) == -1) {
 355                         tfaillog(*fdreadp, "tsetup: t_sync\n");
 356                         return (FAIL);
 357                 }
 358         }
 359         return (SUCCESS);
 360 }
 361
 362 /*
 363  *      tteardown - tli shutdown routine
 364  */
 365 /*ARGSUSED*/
 366 static int
 367 tteardown(role, fdread, fdwrite)
 368 {
 369         (void) t_unbind(fdread);
 370         (void) t_close(fdread);
 371         return (SUCCESS);
 372 }
 373
 374 #ifdef TLIS
 375 /*
 376  *      tssetup - tli, with streams module, setup routine
 377  *      note blatant assumption that *fdreadp == *fdwritep
 378  */
 379 static int
 380 tssetup(role, fdreadp, fdwritep)
 381 int     role;
 382 int     *fdreadp;
 383 int     *fdwritep;
 384 {
 385         if (role == SLAVE) {
 386                 *fdreadp = 0;
 387                 *fdwritep = 1;
 388                 /* 2 has been re-opened to RMTDEBUG in main() */
 389                 DEBUG(5, "tssetup: SLAVE mode: leaving ok\n%s", "");
 390                 return (SUCCESS);
 391         }
 392
 393         DEBUG(4, "tssetup: MASTER mode: leaving ok\n%s", "");
 394         return (SUCCESS);
 395 }
 396
 397 /*
 398  *      Report why a TLI call failed.
 399  */
 400 GLOBAL void
 401 tfaillog(fd, s)
 402 int     fd;
 403 char    *s;
 404 {
 405         char    fmt[ BUFSIZ ];
 406
 407         if (0 < t_errno && t_errno < t_nerr) {
 408                 sprintf(fmt, "%s: %%s\n", s);
 409                 DEBUG(5, fmt, t_errlist[t_errno]);
 410                 logent(s, t_errlist[t_errno]);
 411                 if (t_errno == TSYSERR) {
 412                         strcpy(fmt, "tlicall: system error: %s\n");
 413                         DEBUG(5, fmt, strerror(errno));
 414                 } else if (t_errno == TLOOK) {
 415                         show_tlook(fd);
 416                 }
 417         } else {
 418                 sprintf(fmt, "unknown tli error %d", t_errno);
 419                 logent(s, fmt);
 420                 sprintf(fmt, "%s: unknown tli error %d", s, t_errno);
 421                 DEBUG(5, fmt, 0);
 422                 sprintf(fmt, "%s: %%s\n", s);
 423                 DEBUG(5, fmt, strerror(errno));
 424         }
 425 }
 426
 427 GLOBAL void
 428 show_tlook(fd)
 429 int fd;
 430 {
 431         register int reason;
 432         register char *msg;
 433         extern int      t_errno;
 434 /*
 435  * Find out the current state of the interface.
 436  */
 437         errno = t_errno = 0;
 438         switch (reason = t_getstate(fd)) {
 439         case T_UNBND:           msg = "T_UNBIND";       break;
 440         case T_IDLE:            msg = "T_IDLE";         break;
 441         case T_OUTCON:          msg = "T_OUTCON";       break;
 442         case T_INCON:           msg = "T_INCON";        break;
 443         case T_DATAXFER:        msg = "T_DATAXFER";     break;
 444         case T_OUTREL:          msg = "T_OUTREL";       break;
 445         case T_INREL:           msg = "T_INREL";        break;
 446         default:                msg = NULL;             break;
 447         }
 448         if (msg == NULL)
 449                 return;
 450
 451         DEBUG(5, "state is %s", msg);
 452         switch (reason = t_look(fd)) {
 453         case -1:                msg = ""; break;
 454         case 0:                 msg = "NO ERROR"; break;
 455         case T_LISTEN:          msg = "T_LISTEN"; break;
 456         case T_CONNECT:         msg = "T_CONNECT"; break;
 457         case T_DATA:            msg = "T_DATA";  break;
 458         case T_EXDATA:          msg = "T_EXDATA"; break;
 459         case T_DISCONNECT:      msg = "T_DISCONNECT"; break;
 460         case T_ORDREL:          msg = "T_ORDREL"; break;
 461         case T_UDERR:           msg = "T_UDERR"; break;
 462         default:                msg = "UNKNOWN ERROR"; break;
 463         }
 464         DEBUG(4, " reason is %s\n", msg);
 465
 466         if (reason == T_DISCONNECT)
 467         {
 468                 struct t_discon *dropped;
 469                 if (((dropped =
 470                     (struct t_discon *)t_alloc(fd, T_DIS, T_ALL)) == 0) ||
 471                     (t_rcvdis(fd, dropped) == -1)) {
 472                         if (dropped)
 473                                 t_free((char *)dropped, T_DIS);
 474                         return;
 475                 }
 476                 DEBUG(5, "disconnect reason #%d\n", dropped->reason);
 477                 t_free((char *)dropped, T_DIS);
 478         }
 479 }
 480
 481 #endif /*  TLIS  */
 482
 483 #endif /*  TLI  */