usr/src/cmd/bnu/eio.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 (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  27 /*        All Rights Reserved   */
  28
  29
  30 #pragma ident   "%Z%%M% %I%     %E% SMI"
  31
  32 #include "uucp.h"
  33
  34 #ifdef  E_PROTOCOL
  35
  36 #ifndef MIN
  37 #define     MIN(a,b) (((a)<(b))?(a):(b))
  38 #endif
  39
  40 #if defined(BSD4_2) || defined (ATTSVR4)
  41 #include <netinet/in.h>
  42 #endif /* BSD4_2 || ATTSVR4 */
  43
  44 #define EBUFSIZ 1024
  45 #define EMESGLEN 20
  46
  47 #define TBUFSIZE 1024
  48 #define TPACKSIZE       512
  49
  50 extern long lseek();    /* Find offset into the file. */
  51 static jmp_buf Failbuf;
  52 extern int erdblk();
  53 extern unsigned msgtime;
  54
  55 static char Erdstash[EBUFSIZ];
  56 static int Erdlen;
  57
  58 /*
  59  * error-free channel protocol
  60  */
  61 /* ARGSUSED */
  62 static void
  63 ealarm(sig)
  64 int sig;
  65 {
  66         longjmp(Failbuf, 1);
  67 }
  68 static void (*esig)();
  69
  70 /*
  71  * turn on protocol timer
  72  */
  73 int
  74 eturnon()
  75 {
  76         esig=signal(SIGALRM, ealarm);
  77         return(0);
  78 }
  79
  80 int
  81 eturnoff()
  82 {
  83         signal(SIGALRM, esig);
  84         return(0);
  85 }
  86
  87 /*
  88  * write message across link
  89  *      type    -> message type
  90  *      str     -> message body (ascii string)
  91  *      fn      -> link file descriptor
  92  * return
  93  *      FAIL    -> write failed
  94  *      SUCCESS -> write succeeded
  95  */
  96 int
  97 ewrmsg(type, str, fn)
  98 char *str;
  99 int fn;
 100 char type;
 101 {
 102         return(etwrmsg(type, str, fn, 0));
 103 }
 104
 105 /*
 106  * read message from link
 107  *      str     -> message buffer
 108  *      fn      -> file descriptor
 109  * return
 110  *      FAIL    -> read timed out
 111  *      SUCCESS -> ok message in str
 112  */
 113 int
 114 erdmsg(str, fn)
 115 char *str;
 116 {
 117         return(etrdmsg(str, fn, 0));
 118 }
 119
 120 /*
 121  * read data from file fp1 and write
 122  * on link
 123  *      fp1     -> file descriptor
 124  *      fn      -> link descriptor
 125  * returns:
 126  *      FAIL    ->failure in link
 127  *      SUCCESS -> ok
 128  */
 129 int
 130 ewrdata(fp1, fn)
 131 FILE *fp1;
 132 int     fn;
 133 {
 134         int ret;
 135         int     fd1;
 136         int len;
 137         unsigned long bytes;
 138         char bufr[EBUFSIZ];
 139         struct stat     statbuf;
 140         off_t   msglen;
 141         char    cmsglen[EMESGLEN];
 142         off_t   startPoint;     /* Offset from begining of the file in
 143                                  *   case we are restarting from a check
 144                                  *   point.
 145                                  */
 146
 147         if (setjmp(Failbuf)) {
 148                 DEBUG(7, "ewrdata failed\n%s", "");
 149                 return(FAIL);
 150         }
 151         bytes = 0L;
 152         fd1 = fileno(fp1);
 153         fstat(fd1, &statbuf);
 154         startPoint = lseek(fd1, 0L, 1);
 155         if (startPoint < 0)
 156         {
 157                 DEBUG(7, "ewrdata lseek failed.  Errno=%d\n", errno);
 158                 return(FAIL);
 159         }
 160         msglen = statbuf.st_size - startPoint;
 161         if (msglen < 0)
 162         {
 163                 DEBUG(7, "ewrdata: startPoint past end of file.\n%s", "");
 164                 return(FAIL);
 165         }
 166         sprintf(cmsglen, "%ld", (long) msglen);
 167         DEBUG(9, "ewrdata writing %d ...", sizeof(cmsglen));
 168         alarm(msgtime);
 169         ret = (*Write)(fn, cmsglen, sizeof(cmsglen));
 170         alarm(0);
 171         DEBUG(9, "ret %d\n", ret);
 172         if (ret != sizeof(cmsglen))
 173                 return(FAIL);
 174         DEBUG(7, "ewrdata planning to send %ld bytes to remote.\n", msglen);
 175         while ((len = read( fd1, bufr, EBUFSIZ )) > 0) {
 176                 DEBUG(9, "ewrdata writing %d ...", len);
 177                 alarm(msgtime);
 178                 bytes += len;
 179                 putfilesize(bytes);
 180                 ret = (*Write)(fn, bufr, (unsigned) len);
 181                 alarm(0);
 182                 DEBUG(9, "ewrdata ret %d\n", ret);
 183                 if (ret != len)
 184                         return(FAIL);
 185                 if ((msglen -= len) <= 0)
 186                         break;
 187         }
 188         if (len < 0 || (len == 0 && msglen != 0)) return(FAIL);
 189         return(SUCCESS);
 190 }
 191
 192 /*
 193  * read data from link and
 194  * write into file
 195  *      fp2     -> file descriptor
 196  *      fn      -> link descriptor
 197  * returns:
 198  *      SUCCESS -> ok
 199  *      FAIL    -> failure on link
 200  */
 201 int
 202 erddata(fn, fp2)
 203 FILE *fp2;
 204 {
 205         int ret;
 206         int     fd2;
 207         char bufr[EBUFSIZ];
 208         int     len;
 209         long    msglen, bytes;
 210         char    cmsglen[EMESGLEN], *cptr, *erdptr = Erdstash;
 211
 212         DEBUG(9, "erddata wants %d\n", sizeof(cmsglen));
 213         if (Erdlen > 0) {
 214                 DEBUG(9, "%d bytes stashed\n", Erdlen);
 215                 if (Erdlen >= sizeof(cmsglen)) {
 216                         memcpy(cmsglen, erdptr, sizeof(cmsglen));
 217                         Erdlen -= sizeof(cmsglen);
 218                         erdptr += sizeof(cmsglen);
 219                         ret = len = 0;
 220                 } else {
 221                         memcpy(cmsglen, Erdstash, Erdlen);
 222                         cptr = cmsglen + Erdlen;
 223                         len = sizeof(cmsglen) - Erdlen;
 224                         ret = erdblk(cptr, len, fn);
 225                         Erdlen = 0;
 226                 }
 227         } else {
 228                 len = sizeof(cmsglen);
 229                 ret = erdblk(cmsglen, sizeof(cmsglen), fn);
 230         }
 231         if (ret != len)
 232                 return(FAIL);
 233         ret = SUCCESS;
 234         sscanf(cmsglen, "%ld", &msglen);
 235         if ( ((msglen-1)/512 +1) > Ulimit )
 236                 ret = EFBIG;
 237         DEBUG(7, "erddata file is %ld bytes\n", msglen);
 238         fd2 = fileno( fp2 );
 239
 240         if (Erdlen > 0) {
 241                 DEBUG(9, "%d bytes stashed\n", Erdlen);
 242                 if (write(fileno(fp2), erdptr, Erdlen) != Erdlen)
 243                         return(FAIL);
 244                 msglen -= Erdlen;
 245                 Erdlen = 0;
 246                 DEBUG(7, "erddata remainder is %ld bytes\n", msglen);
 247         }
 248
 249         for (;;) {
 250                 len = erdblk(bufr, (int) MIN(msglen, EBUFSIZ), fn);
 251                 DEBUG(9, "erdblk ret %d\n", len);
 252                 if (len < 0) {
 253                         DEBUG(7, "erdblk failed\n%s", "");
 254                         return(FAIL);
 255                 }
 256
 257                 /*
 258                  * handle the case for remote socket close.
 259                  */
 260                 if (len == 0) {
 261                         ret = errno;
 262                         DEBUG(7, "erddata: remote socket closed, errno %d\n",
 263                                     ret);
 264                         break;
 265                 }
 266                 bytes += len;
 267                 putfilesize(bytes);
 268                 if ((msglen -= len) < 0) {
 269                         DEBUG(7, "erdblk read too much\n%s", "");
 270                         return(FAIL);
 271                 }
 272                 /* this write is to file -- use write(2), not (*Write) */
 273                 if ( ret == SUCCESS && write( fd2, bufr, len ) != len ) {
 274                         ret = errno;
 275                         DEBUG(7, "erddata: write to file failed, errno %d\n", ret);
 276                 }
 277                 if (msglen == 0)
 278                         break;
 279         }
 280         return(ret);
 281 }
 282
 283 /*
 284  * read block from link
 285  * reads are timed
 286  *      blk     -> address of buffer
 287  *      len     -> size to read
 288  *      fn      -> link descriptor
 289  * returns:
 290  *      FAIL    -> link error timeout on link
 291  *      i       -> # of bytes read (must not be 0)
 292  */
 293 int
 294 erdblk(blk, len,  fn)
 295 char *blk;
 296 {
 297         int i, ret;
 298
 299         if(setjmp(Failbuf)) {
 300                 DEBUG(7, "timeout (%d sec)\n", msgtime);
 301                 return(FAIL);
 302         }
 303
 304         alarm(msgtime);
 305         for (i = 0; i < len; i += ret) {
 306                 DEBUG(9, "erdblk ask %d ", len - i);
 307                 if ((ret = (*Read)(fn, blk, (unsigned) len - i)) < 0) {
 308                         alarm(0);
 309                         DEBUG(7, "erdblk read failed\n%s", "");
 310                         return(FAIL);
 311                 }
 312                 DEBUG(9, "erdblk got %d\n", ret);
 313                 if (ret == 0)
 314                         break;
 315                 blk += ret;
 316         }
 317         alarm(0);
 318         return(i);
 319 }
 320
 321 struct tbuf {
 322         long t_nbytes;
 323         char t_data[TBUFSIZE];
 324 };
 325
 326 /*
 327  * read message from link
 328  *      str     -> message buffer
 329  *      fn      -> file descriptor
 330  * return
 331  *      FAIL    -> read timed out
 332  *      SUCCESS -> ok message in str
 333  */
 334 int
 335 trdmsg(str, fn)
 336 char *str;
 337 {
 338         return(etrdmsg(str, fn, TPACKSIZE));
 339 }
 340
 341 /*
 342  * write message across link
 343  *      type    -> message type
 344  *      str     -> message body (ascii string)
 345  *      fn      -> link file descriptor
 346  * return
 347  *      FAIL    -> write failed
 348  *      SUCCESS -> write succeeded
 349  */
 350 int
 351 twrmsg(type, str, fn)
 352 char type;
 353 char *str;
 354 {
 355         return(etwrmsg(type, str, fn, TPACKSIZE));
 356 }
 357
 358 /*
 359  * read data from file fp1 and write on link
 360  *      fp1     -> file descriptor
 361  *      fn      -> link descriptor
 362  * returns:
 363  *      FAIL    ->failure in link
 364  *      SUCCESS -> ok
 365  */
 366 int
 367 twrdata(fp1, fn)
 368 FILE *fp1;
 369 int     fn;
 370 {
 371         int ret;
 372         int len;
 373         unsigned long bytes;
 374         struct tbuf bufr;
 375         struct stat statbuf;
 376
 377         if (setjmp(Failbuf)) {
 378                 DEBUG(7, "twrdata failed\n", 0);
 379                 return(FAIL);
 380         }
 381         fstat(fileno(fp1), &statbuf);
 382         bytes = 0L;
 383         while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
 384                 bufr.t_nbytes = htonl((long)len);
 385                 DEBUG(7, "twrdata writing %d ...", len);
 386                 bytes += len;
 387                 putfilesize(bytes);
 388                 len += sizeof(long);
 389                 alarm(msgtime);
 390                 ret = (*Write)(fn, (char *)&bufr, (unsigned) len);
 391                 alarm(0);
 392                 DEBUG(7, "ret %d\n", ret);
 393                 if (ret != len)
 394                         return(FAIL);
 395                 if (len != TBUFSIZE+sizeof(long))
 396                         break;
 397         }
 398         bufr.t_nbytes = 0;
 399         alarm(msgtime);
 400         ret = write(fn, (char *)&bufr, sizeof(long));
 401         alarm(0);
 402         if (ret != sizeof(long))
 403                 return FAIL;
 404         return(SUCCESS);
 405 }
 406
 407 /*
 408  * read data from link and write into file
 409  *      fp2     -> file descriptor
 410  *      fn      -> link descriptor
 411  * returns:
 412  *      SUCCESS -> ok
 413  *      FAIL    -> failure on link
 414  */
 415 int
 416 trddata(fn, fp2)
 417 FILE *fp2;
 418 {
 419         int len, nread;
 420         long Nbytes;
 421         unsigned long bytes = 0L;
 422         char bufr[TBUFSIZE];
 423
 424         for (;;) {
 425                 len = erdblk((char *)&Nbytes, sizeof(Nbytes), fn);
 426                 DEBUG(7, "trddata ret %d\n", len);
 427                 if (len != sizeof(Nbytes))
 428                         return(FAIL);
 429                 Nbytes = ntohl(Nbytes);
 430                 DEBUG(7,"trddata expecting %ld bytes\n", Nbytes);
 431                 nread = Nbytes;
 432                 if (nread == 0)
 433                         break;
 434                 len = erdblk(bufr, nread, fn);
 435                 if (len != Nbytes)
 436                         return(FAIL);
 437                 bytes += len;
 438                 putfilesize(bytes);
 439                 if (write(fileno(fp2), bufr, len) != len)
 440                         return(FAIL);
 441         }
 442         return(SUCCESS);
 443 }
 444
 445 /*
 446  * read message from link
 447  *      str     -> message buffer
 448  *      fn      -> file descriptor
 449  *      i       -> if non-zero, amount to read; o.w., read up to '\0'
 450  * return
 451  *      FAIL    -> read timed out
 452  *      SUCCESS -> ok message in str
 453  *
 454  * 'e' is fatally flawed -- in a byte stream world, rdmsg can pick up
 455  * the cmsglen on a R request.  if this happens, we stash the excess
 456  * where rddata can pick it up.
 457  */
 458
 459 int
 460 etrdmsg(str, fn, i)
 461 char *str;
 462 int i;
 463 {
 464         int len;
 465         int nullterm = 0;
 466         char *null, *argstr;
 467
 468
 469         if (i == 0) {
 470                 DEBUG(9, "etrdmsg looking for null terminator\n", 0);
 471                 nullterm++;
 472                 i = EBUFSIZ;
 473                 argstr = str;
 474         }
 475
 476         if(setjmp(Failbuf)) {
 477                 DEBUG(7, "timeout (%d sec)\n", msgtime);
 478                 return(FAIL);
 479         }
 480
 481         alarm(msgtime);
 482         for (;;) {
 483                 DEBUG(9, "etrdmsg want %d ...", i);
 484                 len = (*Read)(fn, str, i);
 485                 DEBUG(9, "got %d\n", len);
 486                 if (len == 0)
 487                         continue;       /* timeout will get this */
 488                 if (len < 0) {
 489                         alarm(0);
 490                         return(FAIL);
 491                 }
 492                 str += len;
 493                 i -= len;
 494                 if (nullterm) {
 495                         /* no way can a msg be as long as EBUFSIZ-1 ... */
 496                         *str = 0;
 497                         null = strchr(argstr, '\0');
 498                         if (null != str) {
 499                                 null++; /* start of stash */
 500                                 memcpy(Erdstash + Erdlen, null, str - null);
 501                                 Erdlen += str - null;
 502                                 break;
 503                         } else
 504                                 argstr = str;
 505                 } else {
 506                         if (i == 0)
 507                                 break;
 508                 }
 509         }
 510         alarm(0);
 511         return(SUCCESS);
 512 }
 513
 514 /*
 515  * write message across link
 516  *      type    -> message type
 517  *      str     -> message body (ascii string)
 518  *      fn      -> link file descriptor
 519  *      len     -> if non-zero, amount to write;
 520                    o.w., write up to '\0' (inclusive)
 521  * return
 522  *      FAIL    -> write failed
 523  *      SUCCESS -> write succeeded
 524  */
 525 int
 526 etwrmsg(type, str, fn, len)
 527 char type;
 528 char *str;
 529 int fn, len;
 530 {
 531         char bufr[EBUFSIZ], *endstr;
 532         int ret;
 533
 534         bufr[0] = type;
 535
 536         /* point endstr to last character to be sent */
 537         if ((endstr = strchr(str, '\n')) != 0)
 538                 *endstr = 0;
 539         else
 540                 endstr = str + strlen(str);
 541
 542         memcpy(bufr+1, str, (endstr - str) + 1);        /* include '\0' */
 543         if (len == 0)
 544                 len = (endstr - str) + 2;       /* include bufr[0] and '\0' */
 545         else
 546                 bufr[len-1] = 0;                /* 't' needs this terminator */
 547
 548
 549         if (setjmp(Failbuf)) {
 550                 DEBUG(7, "etwrmsg write failed\n", 0);
 551                 return(FAIL);
 552         }
 553         DEBUG(9, "etwrmsg want %d ... ", len);
 554         alarm(msgtime);
 555         ret = (*Write)(fn, bufr, (unsigned) len);
 556         alarm(0);
 557         DEBUG(9, "sent %d\n", ret);
 558         if (ret != len)
 559                 return(FAIL);
 560         return(SUCCESS);
 561 }
 562 #endif  /* E_PROTOCOL */