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 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T     */
  28 /*        All Rights Reserved   */
  29 
  30 
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  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                                         */
  83 #endif /*  TLI  */
  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 first
 100                                         i/o operation */
 101         int     (*IN_teardown)();       /* teardown function, called after last
 102                                         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( !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", fdread);
 248         if ( ioctl(fdwrite, DIOCFLUSH, NULL) != 0 )
 249                 DEBUG(4, "dkteardown: DIOCFLUSH of output fd %d failed", fdwrite);
 250 
 251         (void)close(fdread);
 252         (void)close(fdwrite);
 253         return(SUCCESS);
 254 }
 255 #endif /* DATAKIT */
 256 
 257 
 258 #ifdef TLI
 259 /*
 260  *      tread - tli read routine
 261  */
 262 static ssize_t
 263 tread(fd, buf, nbytes)
 264 int             fd;
 265 char            *buf;
 266 unsigned        nbytes;
 267 {
 268         int             rcvflags;
 269 
 270         return((ssize_t)t_rcv(fd, buf, nbytes, &rcvflags));
 271 }
 272 
 273 /*
 274  *      twrite - tli write routine
 275  */
 276 #define N_CHECK 100
 277 static ssize_t
 278 twrite(fd, buf, nbytes)
 279 int             fd;
 280 char            *buf;
 281 unsigned        nbytes;
 282 {
 283         register int            i, ret;
 284         static int              n_writ, got_info;
 285         static struct t_info    info;
 286 
 287         if ( got_info == 0 ) {
 288                 if ( t_getinfo(fd, &info) != 0 ) {
 289                         tfaillog(fd, "twrite: t_getinfo\n");
 290                         return(FAIL);
 291                 }
 292                 got_info = 1;
 293         }
 294 
 295         /* on every N_CHECKth call, check that are still in DATAXFER state */
 296         if ( ++n_writ == N_CHECK ) {
 297                 n_writ = 0;
 298                 if ( t_getstate(fd) != T_DATAXFER )
 299                         return(FAIL);
 300         }       
 301 
 302         if ( info.tsdu <= 0 || nbytes <= info.tsdu )
 303                 return(t_snd(fd, buf, nbytes, NULL));
 304 
 305         /* if get here, then there is a limit on transmit size  */
 306         /* (info.tsdu > 0) and buf exceeds it                        */
 307         i = ret = 0;
 308         while ( nbytes >= info.tsdu ) {
 309                 if ( (ret = t_snd(fd,  &buf[i], info.tsdu, NULL)) != info.tsdu )
 310                         return( ( ret >= 0 ? (i + ret) : ret ) );
 311                 i += info.tsdu;
 312                 nbytes -= info.tsdu;
 313         }
 314         if ( nbytes != 0 ) {
 315                 if ( (ret = t_snd(fd,  &buf[i], nbytes, NULL)) != nbytes )
 316                         return( (ssize_t)( ret >= 0 ? (i + ret) : ret ) );
 317                 i += nbytes;
 318         }
 319         return((ssize_t)i);
 320 }
 321 
 322 
 323 /*
 324  *      tioctl - stub for tli ioctl routine
 325  */
 326 /*ARGSUSED*/
 327 static int
 328 #ifdef __STDC__
 329 tioctl(int fd, int request, ...)
 330 #else
 331 tioctl(fd, request, arg)
 332 int     fd, request;
 333 #endif
 334 {
 335         return(SUCCESS);
 336 }
 337 
 338 /*
 339  *      tsetup - tli setup routine
 340  *      note blatant assumption that *fdreadp == *fdwritep == 0
 341  */
 342 static int
 343 tsetup( role, fdreadp, fdwritep )
 344 int     *fdreadp, *fdwritep;
 345 {
 346 
 347         if ( role == SLAVE ) {
 348                 *fdreadp = 0;
 349                 *fdwritep = 1;
 350                 /* 2 has been re-opened to RMTDEBUG in main() */
 351                 errno = t_errno = 0;
 352                 if ( t_sync(*fdreadp) == -1 || t_sync(*fdwritep) == -1 ) {
 353                         tfaillog(*fdreadp, "tsetup: t_sync\n");
 354                         return(FAIL);
 355                 }
 356         }
 357         return(SUCCESS);
 358 }
 359 
 360 /*
 361  *      tteardown - tli shutdown routine
 362  */
 363 /*ARGSUSED*/
 364 static int
 365 tteardown( role, fdread, fdwrite )
 366 {
 367         (void)t_unbind(fdread);
 368         (void)t_close(fdread);
 369         return(SUCCESS);
 370 }
 371 
 372 #ifdef TLIS
 373 /*
 374  *      tssetup - tli, with streams module, setup routine
 375  *      note blatant assumption that *fdreadp == *fdwritep
 376  */
 377 static int
 378 tssetup( role, fdreadp, fdwritep )
 379 int     role;
 380 int     *fdreadp;
 381 int     *fdwritep;
 382 {
 383         if ( role == SLAVE ) {
 384                 *fdreadp = 0;
 385                 *fdwritep = 1;
 386                 /* 2 has been re-opened to RMTDEBUG in main() */
 387                 DEBUG(5, "tssetup: SLAVE mode: leaving ok\n%s", "");
 388                 return(SUCCESS);
 389         }
 390 
 391         DEBUG(4, "tssetup: MASTER mode: leaving ok\n%s", "");
 392         return(SUCCESS);
 393 }
 394 
 395 /*
 396  *      Report why a TLI call failed.
 397  */
 398 GLOBAL void
 399 tfaillog(fd, s)
 400 int     fd;
 401 char    *s;
 402 {
 403         char    fmt[ BUFSIZ ];
 404 
 405         if (0 < t_errno && t_errno < t_nerr) {
 406                 sprintf( fmt, "%s: %%s\n", s );
 407                 DEBUG(5, fmt, t_errlist[t_errno]);
 408                 logent(s, t_errlist[t_errno]);
 409                 if ( t_errno == TSYSERR ) {
 410                         strcpy(fmt, "tlicall: system error: %s\n");
 411                         DEBUG(5, fmt, strerror(errno));
 412                 } else if ( t_errno == TLOOK ) {
 413                         show_tlook(fd);
 414                 }
 415         } else {
 416                 sprintf(fmt, "unknown tli error %d", t_errno);
 417                 logent(s, fmt);
 418                 sprintf(fmt, "%s: unknown tli error %d", s, t_errno);
 419                 DEBUG(5, fmt, 0);
 420                 sprintf(fmt, "%s: %%s\n", s);
 421                 DEBUG(5, fmt, strerror(errno));
 422         }
 423         return;
 424 }
 425 
 426 GLOBAL void
 427 show_tlook(fd)
 428 int fd;
 429 {
 430         register int reason;
 431         register char *msg;
 432         extern int      t_errno;
 433 /*
 434  * Find out the current state of the interface.
 435  */
 436         errno = t_errno = 0;
 437         switch( reason = t_getstate(fd) ) {
 438         case T_UNBND:           msg = "T_UNBIND";       break;
 439         case T_IDLE:            msg = "T_IDLE";         break;
 440         case T_OUTCON:          msg = "T_OUTCON";       break;
 441         case T_INCON:           msg = "T_INCON";        break;
 442         case T_DATAXFER:        msg = "T_DATAXFER";     break;
 443         case T_OUTREL:          msg = "T_OUTREL";       break;
 444         case T_INREL:           msg = "T_INREL";        break;
 445         default:                msg = NULL;             break;
 446         }
 447         if( msg == NULL )
 448                 return;
 449 
 450         DEBUG(5, "state is %s", msg);
 451         switch( reason = t_look(fd) ) {
 452         case -1:                msg = ""; break;
 453         case 0:                 msg = "NO ERROR"; break;
 454         case T_LISTEN:          msg = "T_LISTEN"; break;
 455         case T_CONNECT:         msg = "T_CONNECT"; break;
 456         case T_DATA:            msg = "T_DATA";  break;
 457         case T_EXDATA:          msg = "T_EXDATA"; break;
 458         case T_DISCONNECT:      msg = "T_DISCONNECT"; break;
 459         case T_ORDREL:          msg = "T_ORDREL"; break;
 460         case T_ERROR:           msg = "T_ERROR"; 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         return;
 480 }
 481 
 482 #endif /*  TLIS  */
 483 
 484 #endif /*  TLI  */