doio.c

   1 /*    doio.c
   2  *
   3  *    Copyright (c) 1991-1994, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 /*
  11  * "Far below them they saw the white waters pour into a foaming bowl, and
  12  * then swirl darkly about a deep oval basin in the rocks, until they found
  13  * their way out again through a narrow gate, and flowed away, fuming and
  14  * chattering, into calmer and more level reaches."
  15  */
  16
  17 #include "EXTERN.h"
  18 #include "perl.h"
  19
  20 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
  21 #include <sys/ipc.h>
  22 #ifdef HAS_MSG
  23 #include <sys/msg.h>
  24 #endif
  25 #ifdef HAS_SEM
  26 #include <sys/sem.h>
  27 #endif
  28 #ifdef HAS_SHM
  29 #include <sys/shm.h>
  30 # ifndef HAS_SHMAT_PROTOTYPE
  31     extern Shmat_t shmat _((int, char *, int));
  32 # endif
  33 #endif
  34 #endif
  35
  36 #ifdef I_UTIME
  37 #include <utime.h>
  38 #endif
  39 #ifdef I_FCNTL
  40 #include <fcntl.h>
  41 #endif
  42 #ifdef I_SYS_FILE
  43 #include <sys/file.h>
  44 #endif
  45
  46 bool
  47 do_open(gv,name,len,supplied_fp)
  48 GV *gv;
  49 register char *name;
  50 I32 len;
  51 FILE *supplied_fp;
  52 {
  53     FILE *fp;
  54     register IO *io = GvIOn(gv);
  55     char *myname = savepv(name);
  56     int result;
  57     int fd;
  58     int writing = 0;
  59     int dodup;
  60     char mode[3];               /* stdio file mode ("r\0" or "r+\0") */
  61     FILE *saveifp = Nullfp;
  62     FILE *saveofp = Nullfp;
  63     char savetype = ' ';
  64
  65     SAVEFREEPV(myname);
  66     mode[0] = mode[1] = mode[2] = '\0';
  67     name = myname;
  68     forkprocess = 1;            /* assume true if no fork */
  69     while (len && isSPACE(name[len-1]))
  70         name[--len] = '\0';
  71     if (IoIFP(io)) {
  72         fd = fileno(IoIFP(io));
  73         if (IoTYPE(io) == '-')
  74             result = 0;
  75         else if (fd <= maxsysfd) {
  76             saveifp = IoIFP(io);
  77             saveofp = IoOFP(io);
  78             savetype = IoTYPE(io);
  79             result = 0;
  80         }
  81         else if (IoTYPE(io) == '|')
  82             result = my_pclose(IoIFP(io));
  83         else if (IoIFP(io) != IoOFP(io)) {
  84             if (IoOFP(io)) {
  85                 result = fclose(IoOFP(io));
  86                 fclose(IoIFP(io));      /* clear stdio, fd already closed */
  87             }
  88             else
  89                 result = fclose(IoIFP(io));
  90         }
  91         else
  92             result = fclose(IoIFP(io));
  93         if (result == EOF && fd > maxsysfd)
  94             fprintf(stderr,"Warning: unable to close filehandle %s properly.\n",
  95               GvENAME(gv));
  96         IoOFP(io) = IoIFP(io) = Nullfp;
  97     }
  98     if (*name == '+' && len > 1 && name[len-1] != '|') {        /* scary */
  99         mode[1] = *name++;
 100         mode[2] = '\0';
 101         --len;
 102         writing = 1;
 103     }
 104     else  {
 105         mode[1] = '\0';
 106     }
 107     IoTYPE(io) = *name;
 108     if (*name == '|') {
 109         /*SUPPRESS 530*/
 110         for (name++; isSPACE(*name); name++) ;
 111         if (strNE(name,"-"))
 112             TAINT_ENV();
 113         TAINT_PROPER("piped open");
 114         if (dowarn && name[strlen(name)-1] == '|')
 115             warn("Can't do bidirectional pipe");
 116         fp = my_popen(name,"w");
 117         writing = 1;
 118     }
 119     else if (*name == '>') {
 120         TAINT_PROPER("open");
 121         name++;
 122         if (*name == '>') {
 123             mode[0] = IoTYPE(io) = 'a';
 124             name++;
 125         }
 126         else
 127             mode[0] = 'w';
 128         writing = 1;
 129         if (*name == '&') {
 130           duplicity:
 131             dodup = 1;
 132             name++;
 133             if (*name == '=') {
 134                 dodup = 0;
 135                 name++;
 136             }
 137             if (!*name && supplied_fp)
 138                 fp = supplied_fp;
 139             else {
 140                 while (isSPACE(*name))
 141                     name++;
 142                 if (isDIGIT(*name))
 143                     fd = atoi(name);
 144                 else {
 145                     IO* thatio;
 146                     gv = gv_fetchpv(name,FALSE,SVt_PVIO);
 147                     thatio = GvIO(gv);
 148                     if (!thatio) {
 149 #ifdef EINVAL
 150                         SETERRNO(EINVAL,SS$_IVCHAN);
 151 #endif
 152                         goto say_false;
 153                     }
 154                     if (IoIFP(thatio)) {
 155                         fd = fileno(IoIFP(thatio));
 156                         if (IoTYPE(thatio) == 's')
 157                             IoTYPE(io) = 's';
 158                     }
 159                     else
 160                         fd = -1;
 161                 }
 162                 if (dodup)
 163                     fd = dup(fd);
 164                 if (!(fp = fdopen(fd,mode)))
 165                     if (dodup)
 166                         close(fd);
 167             }
 168         }
 169         else {
 170             while (isSPACE(*name))
 171                 name++;
 172             if (strEQ(name,"-")) {
 173                 fp = stdout;
 174                 IoTYPE(io) = '-';
 175             }
 176             else  {
 177                 fp = fopen(name,mode);
 178             }
 179         }
 180     }
 181     else {
 182         if (*name == '<') {
 183             mode[0] = 'r';
 184             name++;
 185             while (isSPACE(*name))
 186                 name++;
 187             if (*name == '&')
 188                 goto duplicity;
 189             if (strEQ(name,"-")) {
 190                 fp = stdin;
 191                 IoTYPE(io) = '-';
 192             }
 193             else
 194                 fp = fopen(name,mode);
 195         }
 196         else if (name[len-1] == '|') {
 197             name[--len] = '\0';
 198             while (len && isSPACE(name[len-1]))
 199                 name[--len] = '\0';
 200             /*SUPPRESS 530*/
 201             for (; isSPACE(*name); name++) ;
 202             if (strNE(name,"-"))
 203                 TAINT_ENV();
 204             TAINT_PROPER("piped open");
 205             fp = my_popen(name,"r");
 206             IoTYPE(io) = '|';
 207         }
 208         else {
 209             IoTYPE(io) = '<';
 210             /*SUPPRESS 530*/
 211             for (; isSPACE(*name); name++) ;
 212             if (strEQ(name,"-")) {
 213                 fp = stdin;
 214                 IoTYPE(io) = '-';
 215             }
 216             else
 217                 fp = fopen(name,"r");
 218         }
 219     }
 220     if (!fp) {
 221         if (dowarn && IoTYPE(io) == '<' && strchr(name, '\n'))
 222             warn(warn_nl, "open");
 223         goto say_false;
 224     }
 225     if (IoTYPE(io) &&
 226       IoTYPE(io) != '|' && IoTYPE(io) != '-') {
 227         if (Fstat(fileno(fp),&statbuf) < 0) {
 228             (void)fclose(fp);
 229             goto say_false;
 230         }
 231         if (S_ISSOCK(statbuf.st_mode))
 232             IoTYPE(io) = 's';   /* in case a socket was passed in to us */
 233 #ifdef HAS_SOCKET
 234         else if (
 235 #ifdef S_IFMT
 236             !(statbuf.st_mode & S_IFMT)
 237 #else
 238             !statbuf.st_mode
 239 #endif
 240         ) {
 241             int buflen = sizeof tokenbuf;
 242             if (getsockname(fileno(fp), (struct sockaddr *)tokenbuf, &buflen) >= 0
 243                 || errno != ENOTSOCK)
 244                 IoTYPE(io) = 's'; /* some OS's return 0 on fstat()ed socket */
 245                                 /* but some return 0 for streams too, sigh */
 246         }
 247 #endif
 248     }
 249     if (saveifp) {              /* must use old fp? */
 250         fd = fileno(saveifp);
 251         if (saveofp) {
 252             fflush(saveofp);            /* emulate fclose() */
 253             if (saveofp != saveifp) {   /* was a socket? */
 254                 fclose(saveofp);
 255                 if (fd > 2)
 256                     Safefree(saveofp);
 257             }
 258         }
 259         if (fd != fileno(fp)) {
 260             int pid;
 261             SV *sv;
 262
 263             dup2(fileno(fp), fd);
 264             sv = *av_fetch(fdpid,fileno(fp),TRUE);
 265             (void)SvUPGRADE(sv, SVt_IV);
 266             pid = SvIVX(sv);
 267             SvIVX(sv) = 0;
 268             sv = *av_fetch(fdpid,fd,TRUE);
 269             (void)SvUPGRADE(sv, SVt_IV);
 270             SvIVX(sv) = pid;
 271             fclose(fp);
 272
 273         }
 274         fp = saveifp;
 275         clearerr(fp);
 276     }
 277 #if defined(HAS_FCNTL) && defined(F_SETFD)
 278     fd = fileno(fp);
 279     fcntl(fd,F_SETFD,fd > maxsysfd);
 280 #endif
 281     IoIFP(io) = fp;
 282     if (writing) {
 283         if (IoTYPE(io) == 's'
 284           || (IoTYPE(io) == '>' && S_ISCHR(statbuf.st_mode)) ) {
 285             if (!(IoOFP(io) = fdopen(fileno(fp),"w"))) {
 286                 fclose(fp);
 287                 IoIFP(io) = Nullfp;
 288                 goto say_false;
 289             }
 290         }
 291         else
 292             IoOFP(io) = fp;
 293     }
 294     return TRUE;
 295
 296 say_false:
 297     IoIFP(io) = saveifp;
 298     IoOFP(io) = saveofp;
 299     IoTYPE(io) = savetype;
 300     return FALSE;
 301 }
 302
 303 FILE *
 304 nextargv(gv)
 305 register GV *gv;
 306 {
 307     register SV *sv;
 308 #ifndef FLEXFILENAMES
 309     int filedev;
 310     int fileino;
 311 #endif
 312     int fileuid;
 313     int filegid;
 314
 315     if (!argvoutgv)
 316         argvoutgv = gv_fetchpv("ARGVOUT",TRUE,SVt_PVIO);
 317     if (filemode & (S_ISUID|S_ISGID)) {
 318         fflush(IoIFP(GvIOn(argvoutgv)));  /* chmod must follow last write */
 319 #ifdef HAS_FCHMOD
 320         (void)fchmod(lastfd,filemode);
 321 #else
 322         (void)chmod(oldname,filemode);
 323 #endif
 324     }
 325     filemode = 0;
 326     while (av_len(GvAV(gv)) >= 0) {
 327         STRLEN len;
 328         sv = av_shift(GvAV(gv));
 329         SAVEFREESV(sv);
 330         sv_setsv(GvSV(gv),sv);
 331         SvSETMAGIC(GvSV(gv));
 332         oldname = SvPVx(GvSV(gv), len);
 333         if (do_open(gv,oldname,len,Nullfp)) {
 334             if (inplace) {
 335                 TAINT_PROPER("inplace open");
 336                 if (strEQ(oldname,"-")) {
 337                     defoutgv = gv_fetchpv("STDOUT",TRUE,SVt_PVIO);
 338                     return IoIFP(GvIOp(gv));
 339                 }
 340 #ifndef FLEXFILENAMES
 341                 filedev = statbuf.st_dev;
 342                 fileino = statbuf.st_ino;
 343 #endif
 344                 filemode = statbuf.st_mode;
 345                 fileuid = statbuf.st_uid;
 346                 filegid = statbuf.st_gid;
 347                 if (!S_ISREG(filemode)) {
 348                     warn("Can't do inplace edit: %s is not a regular file",
 349                       oldname );
 350                     do_close(gv,FALSE);
 351                     continue;
 352                 }
 353                 if (*inplace) {
 354 #ifdef SUFFIX
 355                     add_suffix(sv,inplace);
 356 #else
 357                     sv_catpv(sv,inplace);
 358 #endif
 359 #ifndef FLEXFILENAMES
 360                     if (Stat(SvPVX(sv),&statbuf) >= 0
 361                       && statbuf.st_dev == filedev
 362                       && statbuf.st_ino == fileino ) {
 363                         warn("Can't do inplace edit: %s > 14 characters",
 364                           SvPVX(sv) );
 365                         do_close(gv,FALSE);
 366                         continue;
 367                     }
 368 #endif
 369 #ifdef HAS_RENAME
 370 #ifndef DOSISH
 371                     if (rename(oldname,SvPVX(sv)) < 0) {
 372                         warn("Can't rename %s to %s: %s, skipping file",
 373                           oldname, SvPVX(sv), Strerror(errno) );
 374                         do_close(gv,FALSE);
 375                         continue;
 376                     }
 377 #else
 378                     do_close(gv,FALSE);
 379                     (void)unlink(SvPVX(sv));
 380                     (void)rename(oldname,SvPVX(sv));
 381                     do_open(gv,SvPVX(sv),SvCUR(GvSV(gv)),Nullfp);
 382 #endif /* MSDOS */
 383 #else
 384                     (void)UNLINK(SvPVX(sv));
 385                     if (link(oldname,SvPVX(sv)) < 0) {
 386                         warn("Can't rename %s to %s: %s, skipping file",
 387                           oldname, SvPVX(sv), Strerror(errno) );
 388                         do_close(gv,FALSE);
 389                         continue;
 390                     }
 391                     (void)UNLINK(oldname);
 392 #endif
 393                 }
 394                 else {
 395 #ifndef DOSISH
 396                     if (UNLINK(oldname) < 0) {
 397                         warn("Can't rename %s to %s: %s, skipping file",
 398                           oldname, SvPVX(sv), Strerror(errno) );
 399                         do_close(gv,FALSE);
 400                         continue;
 401                     }
 402 #else
 403                     croak("Can't do inplace edit without backup");
 404 #endif
 405                 }
 406
 407                 sv_setpvn(sv,">",1);
 408                 sv_catpv(sv,oldname);
 409                 SETERRNO(0,0);          /* in case sprintf set errno */
 410                 if (!do_open(argvoutgv,SvPVX(sv),SvCUR(sv),Nullfp)) {
 411                     warn("Can't do inplace edit on %s: %s",
 412                       oldname, Strerror(errno) );
 413                     do_close(gv,FALSE);
 414                     continue;
 415                 }
 416                 defoutgv = argvoutgv;
 417                 lastfd = fileno(IoIFP(GvIOp(argvoutgv)));
 418                 (void)Fstat(lastfd,&statbuf);
 419 #ifdef HAS_FCHMOD
 420                 (void)fchmod(lastfd,filemode);
 421 #else
 422                 (void)chmod(oldname,filemode);
 423 #endif
 424                 if (fileuid != statbuf.st_uid || filegid != statbuf.st_gid) {
 425 #ifdef HAS_FCHOWN
 426                     (void)fchown(lastfd,fileuid,filegid);
 427 #else
 428 #ifdef HAS_CHOWN
 429                     (void)chown(oldname,fileuid,filegid);
 430 #endif
 431 #endif
 432                 }
 433             }
 434             return IoIFP(GvIOp(gv));
 435         }
 436         else
 437             fprintf(stderr,"Can't open %s: %s\n",SvPV(sv, na), Strerror(errno));
 438     }
 439     if (inplace) {
 440         (void)do_close(argvoutgv,FALSE);
 441         defoutgv = gv_fetchpv("STDOUT",TRUE,SVt_PVIO);
 442     }
 443     return Nullfp;
 444 }
 445
 446 #ifdef HAS_PIPE
 447 void
 448 do_pipe(sv, rgv, wgv)
 449 SV *sv;
 450 GV *rgv;
 451 GV *wgv;
 452 {
 453     register IO *rstio;
 454     register IO *wstio;
 455     int fd[2];
 456
 457     if (!rgv)
 458         goto badexit;
 459     if (!wgv)
 460         goto badexit;
 461
 462     rstio = GvIOn(rgv);
 463     wstio = GvIOn(wgv);
 464
 465     if (IoIFP(rstio))
 466         do_close(rgv,FALSE);
 467     if (IoIFP(wstio))
 468         do_close(wgv,FALSE);
 469
 470     if (pipe(fd) < 0)
 471         goto badexit;
 472     IoIFP(rstio) = fdopen(fd[0], "r");
 473     IoOFP(wstio) = fdopen(fd[1], "w");
 474     IoIFP(wstio) = IoOFP(wstio);
 475     IoTYPE(rstio) = '<';
 476     IoTYPE(wstio) = '>';
 477     if (!IoIFP(rstio) || !IoOFP(wstio)) {
 478         if (IoIFP(rstio)) fclose(IoIFP(rstio));
 479         else close(fd[0]);
 480         if (IoOFP(wstio)) fclose(IoOFP(wstio));
 481         else close(fd[1]);
 482         goto badexit;
 483     }
 484
 485     sv_setsv(sv,&sv_yes);
 486     return;
 487
 488 badexit:
 489     sv_setsv(sv,&sv_undef);
 490     return;
 491 }
 492 #endif
 493
 494 bool
 495 #ifndef CAN_PROTOTYPE
 496 do_close(gv,explicit)
 497 GV *gv;
 498 bool explicit;
 499 #else
 500 do_close(GV *gv, bool explicit)
 501 #endif /* CAN_PROTOTYPE */
 502 {
 503     bool retval = FALSE;
 504     register IO *io;
 505     int status;
 506
 507     if (!gv)
 508         gv = argvgv;
 509     if (!gv || SvTYPE(gv) != SVt_PVGV) {
 510         SETERRNO(EBADF,SS$_IVCHAN);
 511         return FALSE;
 512     }
 513     io = GvIO(gv);
 514     if (!io) {          /* never opened */
 515         if (dowarn && explicit)
 516             warn("Close on unopened file <%s>",GvENAME(gv));
 517         return FALSE;
 518     }
 519     if (IoIFP(io)) {
 520         if (IoTYPE(io) == '|') {
 521             status = my_pclose(IoIFP(io));
 522             retval = (status == 0);
 523             statusvalue = FIXSTATUS(status);
 524         }
 525         else if (IoTYPE(io) == '-')
 526             retval = TRUE;
 527         else {
 528             if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {          /* a socket */
 529                 retval = (fclose(IoOFP(io)) != EOF);
 530                 fclose(IoIFP(io));      /* clear stdio, fd already closed */
 531             }
 532             else
 533                 retval = (fclose(IoIFP(io)) != EOF);
 534         }
 535         IoOFP(io) = IoIFP(io) = Nullfp;
 536     }
 537     if (explicit) {
 538         IoLINES(io) = 0;
 539         IoPAGE(io) = 0;
 540         IoLINES_LEFT(io) = IoPAGE_LEN(io);
 541     }
 542     IoTYPE(io) = ' ';
 543     return retval;
 544 }
 545
 546 bool
 547 do_eof(gv)
 548 GV *gv;
 549 {
 550     register IO *io;
 551     int ch;
 552
 553     io = GvIO(gv);
 554
 555     if (!io)
 556         return TRUE;
 557
 558     while (IoIFP(io)) {
 559
 560 #ifdef USE_STD_STDIO                    /* (the code works without this) */
 561         if (IoIFP(io)->_cnt > 0)        /* cheat a little, since */
 562             return FALSE;               /* this is the most usual case */
 563 #endif
 564
 565         ch = getc(IoIFP(io));
 566         if (ch != EOF) {
 567             (void)ungetc(ch, IoIFP(io));
 568             return FALSE;
 569         }
 570 #ifdef USE_STD_STDIO
 571         if (IoIFP(io)->_cnt < -1)
 572             IoIFP(io)->_cnt = -1;
 573 #endif
 574         if (op->op_flags & OPf_SPECIAL) { /* not necessarily a real EOF yet? */
 575             if (!nextargv(argvgv))      /* get another fp handy */
 576                 return TRUE;
 577         }
 578         else
 579             return TRUE;                /* normal fp, definitely end of file */
 580     }
 581     return TRUE;
 582 }
 583
 584 long
 585 do_tell(gv)
 586 GV *gv;
 587 {
 588     register IO *io;
 589
 590     if (!gv)
 591         goto phooey;
 592
 593     io = GvIO(gv);
 594     if (!io || !IoIFP(io))
 595         goto phooey;
 596
 597 #ifdef ULTRIX_STDIO_BOTCH
 598     if (feof(IoIFP(io)))
 599         (void)fseek (IoIFP(io), 0L, 2);         /* ultrix 1.2 workaround */
 600 #endif
 601
 602     return ftell(IoIFP(io));
 603
 604 phooey:
 605     if (dowarn)
 606         warn("tell() on unopened file");
 607     SETERRNO(EBADF,RMS$_IFI);
 608     return -1L;
 609 }
 610
 611 bool
 612 do_seek(gv, pos, whence)
 613 GV *gv;
 614 long pos;
 615 int whence;
 616 {
 617     register IO *io;
 618
 619     if (!gv)
 620         goto nuts;
 621
 622     io = GvIO(gv);
 623     if (!io || !IoIFP(io))
 624         goto nuts;
 625
 626 #ifdef ULTRIX_STDIO_BOTCH
 627     if (feof(IoIFP(io)))
 628         (void)fseek (IoIFP(io), 0L, 2);         /* ultrix 1.2 workaround */
 629 #endif
 630
 631     return fseek(IoIFP(io), pos, whence) >= 0;
 632
 633 nuts:
 634     if (dowarn)
 635         warn("seek() on unopened file");
 636     SETERRNO(EBADF,RMS$_IFI);
 637     return FALSE;
 638 }
 639
 640 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
 641         /* code courtesy of William Kucharski */
 642 #define HAS_CHSIZE
 643
 644 I32 chsize(fd, length)
 645 I32 fd;                 /* file descriptor */
 646 Off_t length;           /* length to set file to */
 647 {
 648     extern long lseek();
 649     struct flock fl;
 650     struct stat filebuf;
 651
 652     if (Fstat(fd, &filebuf) < 0)
 653         return -1;
 654
 655     if (filebuf.st_size < length) {
 656
 657         /* extend file length */
 658
 659         if ((lseek(fd, (length - 1), 0)) < 0)
 660             return -1;
 661
 662         /* write a "0" byte */
 663
 664         if ((write(fd, "", 1)) != 1)
 665             return -1;
 666     }
 667     else {
 668         /* truncate length */
 669
 670         fl.l_whence = 0;
 671         fl.l_len = 0;
 672         fl.l_start = length;
 673         fl.l_type = F_WRLCK;    /* write lock on file space */
 674
 675         /*
 676         * This relies on the UNDOCUMENTED F_FREESP argument to
 677         * fcntl(2), which truncates the file so that it ends at the
 678         * position indicated by fl.l_start.
 679         *
 680         * Will minor miracles never cease?
 681         */
 682
 683         if (fcntl(fd, F_FREESP, &fl) < 0)
 684             return -1;
 685
 686     }
 687
 688     return 0;
 689 }
 690 #endif /* F_FREESP */
 691
 692 I32
 693 looks_like_number(sv)
 694 SV *sv;
 695 {
 696     register char *s;
 697     register char *send;
 698
 699     if (!SvPOK(sv)) {
 700         STRLEN len;
 701         if (!SvPOKp(sv))
 702             return TRUE;
 703         s = SvPV(sv, len);
 704         send = s + len;
 705     }
 706     else {
 707         s = SvPVX(sv);
 708         send = s + SvCUR(sv);
 709     }
 710     while (isSPACE(*s))
 711         s++;
 712     if (s >= send)
 713         return FALSE;
 714     if (*s == '+' || *s == '-')
 715         s++;
 716     while (isDIGIT(*s))
 717         s++;
 718     if (s == send)
 719         return TRUE;
 720     if (*s == '.')
 721         s++;
 722     else if (s == SvPVX(sv))
 723         return FALSE;
 724     while (isDIGIT(*s))
 725         s++;
 726     if (s == send)
 727         return TRUE;
 728     if (*s == 'e' || *s == 'E') {
 729         s++;
 730         if (*s == '+' || *s == '-')
 731             s++;
 732         while (isDIGIT(*s))
 733             s++;
 734     }
 735     while (isSPACE(*s))
 736         s++;
 737     if (s >= send)
 738         return TRUE;
 739     return FALSE;
 740 }
 741
 742 bool
 743 do_print(sv,fp)
 744 register SV *sv;
 745 FILE *fp;
 746 {
 747     register char *tmps;
 748     STRLEN len;
 749
 750     /* assuming fp is checked earlier */
 751     if (!sv)
 752         return TRUE;
 753     if (ofmt) {
 754         if (SvGMAGICAL(sv))
 755             mg_get(sv);
 756         if (SvIOK(sv) && SvIVX(sv) != 0) {
 757             fprintf(fp, ofmt, (double)SvIVX(sv));
 758             return !ferror(fp);
 759         }
 760         if (  (SvNOK(sv) && SvNVX(sv) != 0.0)
 761            || (looks_like_number(sv) && sv_2nv(sv) != 0.0) ) {
 762             fprintf(fp, ofmt, SvNVX(sv));
 763             return !ferror(fp);
 764         }
 765     }
 766     switch (SvTYPE(sv)) {
 767     case SVt_NULL:
 768         if (dowarn)
 769             warn(warn_uninit);
 770         return TRUE;
 771     case SVt_IV:
 772         if (SvIOK(sv)) {
 773             if (SvGMAGICAL(sv))
 774                 mg_get(sv);
 775             fprintf(fp, "%ld", (long)SvIVX(sv));
 776             return !ferror(fp);
 777         }
 778         /* FALL THROUGH */
 779     default:
 780         tmps = SvPV(sv, len);
 781         break;
 782     }
 783     if (len && (fwrite1(tmps,1,len,fp) == 0 || ferror(fp)))
 784         return FALSE;
 785     return TRUE;
 786 }
 787
 788 I32
 789 my_stat(ARGS)
 790 dARGS
 791 {
 792     dSP;
 793     IO *io;
 794     GV* tmpgv;
 795
 796     if (op->op_flags & OPf_REF) {
 797         EXTEND(sp,1);
 798         tmpgv = cGVOP->op_gv;
 799       do_fstat:
 800         io = GvIO(tmpgv);
 801         if (io && IoIFP(io)) {
 802             statgv = tmpgv;
 803             sv_setpv(statname,"");
 804             laststype = OP_STAT;
 805             return (laststatval = Fstat(fileno(IoIFP(io)), &statcache));
 806         }
 807         else {
 808             if (tmpgv == defgv)
 809                 return laststatval;
 810             if (dowarn)
 811                 warn("Stat on unopened file <%s>",
 812                   GvENAME(tmpgv));
 813             statgv = Nullgv;
 814             sv_setpv(statname,"");
 815             return (laststatval = -1);
 816         }
 817     }
 818     else {
 819         SV* sv = POPs;
 820         PUTBACK;
 821         if (SvTYPE(sv) == SVt_PVGV) {
 822             tmpgv = (GV*)sv;
 823             goto do_fstat;
 824         }
 825         else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) {
 826             tmpgv = (GV*)SvRV(sv);
 827             goto do_fstat;
 828         }
 829
 830         statgv = Nullgv;
 831         sv_setpv(statname,SvPV(sv, na));
 832         laststype = OP_STAT;
 833         laststatval = Stat(SvPV(sv, na),&statcache);
 834         if (laststatval < 0 && dowarn && strchr(SvPV(sv, na), '\n'))
 835             warn(warn_nl, "stat");
 836         return laststatval;
 837     }
 838 }
 839
 840 I32
 841 my_lstat(ARGS)
 842 dARGS
 843 {
 844     dSP;
 845     SV *sv;
 846     if (op->op_flags & OPf_REF) {
 847         EXTEND(sp,1);
 848         if (cGVOP->op_gv == defgv) {
 849             if (laststype != OP_LSTAT)
 850                 croak("The stat preceding -l _ wasn't an lstat");
 851             return laststatval;
 852         }
 853         croak("You can't use -l on a filehandle");
 854     }
 855
 856     laststype = OP_LSTAT;
 857     statgv = Nullgv;
 858     sv = POPs;
 859     PUTBACK;
 860     sv_setpv(statname,SvPV(sv, na));
 861 #ifdef HAS_LSTAT
 862     laststatval = lstat(SvPV(sv, na),&statcache);
 863 #else
 864     laststatval = Stat(SvPV(sv, na),&statcache);
 865 #endif
 866     if (laststatval < 0 && dowarn && strchr(SvPV(sv, na), '\n'))
 867         warn(warn_nl, "lstat");
 868     return laststatval;
 869 }
 870
 871 bool
 872 do_aexec(really,mark,sp)
 873 SV *really;
 874 register SV **mark;
 875 register SV **sp;
 876 {
 877     register char **a;
 878     char *tmps;
 879
 880     if (sp > mark) {
 881         New(401,Argv, sp - mark + 1, char*);
 882         a = Argv;
 883         while (++mark <= sp) {
 884             if (*mark)
 885                 *a++ = SvPVx(*mark, na);
 886             else
 887                 *a++ = "";
 888         }
 889         *a = Nullch;
 890         if (*Argv[0] != '/')    /* will execvp use PATH? */
 891             TAINT_ENV();                /* testing IFS here is overkill, probably */
 892         if (really && *(tmps = SvPV(really, na)))
 893             execvp(tmps,Argv);
 894         else
 895             execvp(Argv[0],Argv);
 896         if (dowarn)
 897             warn("Can't exec \"%s\": %s", Argv[0], Strerror(errno));
 898     }
 899     do_execfree();
 900     return FALSE;
 901 }
 902
 903 void
 904 do_execfree()
 905 {
 906     if (Argv) {
 907         Safefree(Argv);
 908         Argv = Null(char **);
 909     }
 910     if (Cmd) {
 911         Safefree(Cmd);
 912         Cmd = Nullch;
 913     }
 914 }
 915
 916 bool
 917 do_exec(cmd)
 918 char *cmd;
 919 {
 920     register char **a;
 921     register char *s;
 922     char flags[10];
 923
 924     while (*cmd && isSPACE(*cmd))
 925         cmd++;
 926
 927     /* save an extra exec if possible */
 928
 929 #ifdef CSH
 930     if (strnEQ(cmd,cshname,cshlen) && strnEQ(cmd+cshlen," -c",3)) {
 931         strcpy(flags,"-c");
 932         s = cmd+cshlen+3;
 933         if (*s == 'f') {
 934             s++;
 935             strcat(flags,"f");
 936         }
 937         if (*s == ' ')
 938             s++;
 939         if (*s++ == '\'') {
 940             char *ncmd = s;
 941
 942             while (*s)
 943                 s++;
 944             if (s[-1] == '\n')
 945                 *--s = '\0';
 946             if (s[-1] == '\'') {
 947                 *--s = '\0';
 948                 execl(cshname,"csh", flags,ncmd,(char*)0);
 949                 *s = '\'';
 950                 return FALSE;
 951             }
 952         }
 953     }
 954 #endif /* CSH */
 955
 956     /* see if there are shell metacharacters in it */
 957
 958     if (*cmd == '.' && isSPACE(cmd[1]))
 959         goto doshell;
 960
 961     if (strnEQ(cmd,"exec",4) && isSPACE(cmd[4]))
 962         goto doshell;
 963
 964     for (s = cmd; *s && isALPHA(*s); s++) ;     /* catch VAR=val gizmo */
 965     if (*s == '=')
 966         goto doshell;
 967
 968     for (s = cmd; *s; s++) {
 969         if (*s != ' ' && !isALPHA(*s) && strchr("$&*(){}[]'\";\\|?<>~`\n",*s)) {
 970             if (*s == '\n' && !s[1]) {
 971                 *s = '\0';
 972                 break;
 973             }
 974           doshell:
 975             execl("/bin/sh","sh","-c",cmd,(char*)0);
 976             return FALSE;
 977         }
 978     }
 979
 980     New(402,Argv, (s - cmd) / 2 + 2, char*);
 981     Cmd = savepvn(cmd, s-cmd);
 982     a = Argv;
 983     for (s = Cmd; *s;) {
 984         while (*s && isSPACE(*s)) s++;
 985         if (*s)
 986             *(a++) = s;
 987         while (*s && !isSPACE(*s)) s++;
 988         if (*s)
 989             *s++ = '\0';
 990     }
 991     *a = Nullch;
 992     if (Argv[0]) {
 993         execvp(Argv[0],Argv);
 994         if (errno == ENOEXEC) {         /* for system V NIH syndrome */
 995             do_execfree();
 996             goto doshell;
 997         }
 998         if (dowarn)
 999             warn("Can't exec \"%s\": %s", Argv[0], Strerror(errno));
1000     }
1001     do_execfree();
1002     return FALSE;
1003 }
1004
1005 I32
1006 apply(type,mark,sp)
1007 I32 type;
1008 register SV **mark;
1009 register SV **sp;
1010 {
1011     register I32 val;
1012     register I32 val2;
1013     register I32 tot = 0;
1014     char *s;
1015     SV **oldmark = mark;
1016
1017     if (tainting) {
1018         while (++mark <= sp) {
1019             MAGIC *mg;
1020             if (SvMAGICAL(*mark) && (mg = mg_find(*mark, 't')) && mg->mg_len & 1)
1021                 tainted = TRUE;
1022         }
1023         mark = oldmark;
1024     }
1025     switch (type) {
1026     case OP_CHMOD:
1027         TAINT_PROPER("chmod");
1028         if (++mark <= sp) {
1029             tot = sp - mark;
1030             val = SvIVx(*mark);
1031             while (++mark <= sp) {
1032                 if (chmod(SvPVx(*mark, na),val))
1033                     tot--;
1034             }
1035         }
1036         break;
1037 #ifdef HAS_CHOWN
1038     case OP_CHOWN:
1039         TAINT_PROPER("chown");
1040         if (sp - mark > 2) {
1041             val = SvIVx(*++mark);
1042             val2 = SvIVx(*++mark);
1043             tot = sp - mark;
1044             while (++mark <= sp) {
1045                 if (chown(SvPVx(*mark, na),val,val2))
1046                     tot--;
1047             }
1048         }
1049         break;
1050 #endif
1051 #ifdef HAS_KILL
1052     case OP_KILL:
1053         TAINT_PROPER("kill");
1054         s = SvPVx(*++mark, na);
1055         tot = sp - mark;
1056         if (isUPPER(*s)) {
1057             if (*s == 'S' && s[1] == 'I' && s[2] == 'G')
1058                 s += 3;
1059             if (!(val = whichsig(s)))
1060                 croak("Unrecognized signal name \"%s\"",s);
1061         }
1062         else
1063             val = SvIVx(*mark);
1064         if (val < 0) {
1065             val = -val;
1066             while (++mark <= sp) {
1067                 I32 proc = SvIVx(*mark);
1068 #ifdef HAS_KILLPG
1069                 if (killpg(proc,val))   /* BSD */
1070 #else
1071                 if (kill(-proc,val))    /* SYSV */
1072 #endif
1073                     tot--;
1074             }
1075         }
1076         else {
1077             while (++mark <= sp) {
1078                 if (kill(SvIVx(*mark),val))
1079                     tot--;
1080             }
1081         }
1082         break;
1083 #endif
1084     case OP_UNLINK:
1085         TAINT_PROPER("unlink");
1086         tot = sp - mark;
1087         while (++mark <= sp) {
1088             s = SvPVx(*mark, na);
1089             if (euid || unsafe) {
1090                 if (UNLINK(s))
1091                     tot--;
1092             }
1093             else {      /* don't let root wipe out directories without -U */
1094 #ifdef HAS_LSTAT
1095                 if (lstat(s,&statbuf) < 0 || S_ISDIR(statbuf.st_mode))
1096 #else
1097                 if (Stat(s,&statbuf) < 0 || S_ISDIR(statbuf.st_mode))
1098 #endif
1099                     tot--;
1100                 else {
1101                     if (UNLINK(s))
1102                         tot--;
1103                 }
1104             }
1105         }
1106         break;
1107 #ifdef HAS_UTIME
1108     case OP_UTIME:
1109         TAINT_PROPER("utime");
1110         if (sp - mark > 2) {
1111 #if defined(I_UTIME) || defined(VMS)
1112             struct utimbuf utbuf;
1113 #else
1114             struct {
1115                 long    actime;
1116                 long    modtime;
1117             } utbuf;
1118 #endif
1119
1120             Zero(&utbuf, sizeof utbuf, char);
1121             utbuf.actime = SvIVx(*++mark);    /* time accessed */
1122             utbuf.modtime = SvIVx(*++mark);    /* time modified */
1123             tot = sp - mark;
1124             while (++mark <= sp) {
1125                 if (utime(SvPVx(*mark, na),&utbuf))
1126                     tot--;
1127             }
1128         }
1129         else
1130             tot = 0;
1131         break;
1132 #endif
1133     }
1134     return tot;
1135 }
1136
1137 /* Do the permissions allow some operation?  Assumes statcache already set. */
1138 #ifndef VMS /* VMS' cando is in vms.c */
1139 I32
1140 cando(bit, effective, statbufp)
1141 I32 bit;
1142 I32 effective;
1143 register struct stat *statbufp;
1144 {
1145 #ifdef DOSISH
1146     /* [Comments and code from Len Reed]
1147      * MS-DOS "user" is similar to UNIX's "superuser," but can't write
1148      * to write-protected files.  The execute permission bit is set
1149      * by the Miscrosoft C library stat() function for the following:
1150      *          .exe files
1151      *          .com files
1152      *          .bat files
1153      *          directories
1154      * All files and directories are readable.
1155      * Directories and special files, e.g. "CON", cannot be
1156      * write-protected.
1157      * [Comment by Tom Dinger -- a directory can have the write-protect
1158      *          bit set in the file system, but DOS permits changes to
1159      *          the directory anyway.  In addition, all bets are off
1160      *          here for networked software, such as Novell and
1161      *          Sun's PC-NFS.]
1162      */
1163
1164      /* Atari stat() does pretty much the same thing. we set x_bit_set_in_stat
1165       * too so it will actually look into the files for magic numbers
1166       */
1167      return (bit & statbufp->st_mode) ? TRUE : FALSE;
1168
1169 #else /* ! MSDOS */
1170     if ((effective ? euid : uid) == 0) {        /* root is special */
1171         if (bit == S_IXUSR) {
1172             if (statbufp->st_mode & 0111 || S_ISDIR(statbufp->st_mode))
1173                 return TRUE;
1174         }
1175         else
1176             return TRUE;                /* root reads and writes anything */
1177         return FALSE;
1178     }
1179     if (statbufp->st_uid == (effective ? euid : uid) ) {
1180         if (statbufp->st_mode & bit)
1181             return TRUE;        /* ok as "user" */
1182     }
1183     else if (ingroup((I32)statbufp->st_gid,effective)) {
1184         if (statbufp->st_mode & bit >> 3)
1185             return TRUE;        /* ok as "group" */
1186     }
1187     else if (statbufp->st_mode & bit >> 6)
1188         return TRUE;    /* ok as "other" */
1189     return FALSE;
1190 #endif /* ! MSDOS */
1191 }
1192 #endif /* ! VMS */
1193
1194 I32
1195 ingroup(testgid,effective)
1196 I32 testgid;
1197 I32 effective;
1198 {
1199     if (testgid == (effective ? egid : gid))
1200         return TRUE;
1201 #ifdef HAS_GETGROUPS
1202 #ifndef NGROUPS
1203 #define NGROUPS 32
1204 #endif
1205     {
1206         Groups_t gary[NGROUPS];
1207         I32 anum;
1208
1209         anum = getgroups(NGROUPS,gary);
1210         while (--anum >= 0)
1211             if (gary[anum] == testgid)
1212                 return TRUE;
1213     }
1214 #endif
1215     return FALSE;
1216 }
1217
1218 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
1219
1220 I32
1221 do_ipcget(optype, mark, sp)
1222 I32 optype;
1223 SV **mark;
1224 SV **sp;
1225 {
1226     key_t key;
1227     I32 n, flags;
1228
1229     key = (key_t)SvNVx(*++mark);
1230     n = (optype == OP_MSGGET) ? 0 : SvIVx(*++mark);
1231     flags = SvIVx(*++mark);
1232     SETERRNO(0,0);
1233     switch (optype)
1234     {
1235 #ifdef HAS_MSG
1236     case OP_MSGGET:
1237         return msgget(key, flags);
1238 #endif
1239 #ifdef HAS_SEM
1240     case OP_SEMGET:
1241         return semget(key, n, flags);
1242 #endif
1243 #ifdef HAS_SHM
1244     case OP_SHMGET:
1245         return shmget(key, n, flags);
1246 #endif
1247 #if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
1248     default:
1249         croak("%s not implemented", op_name[optype]);
1250 #endif
1251     }
1252     return -1;                  /* should never happen */
1253 }
1254
1255 I32
1256 do_ipcctl(optype, mark, sp)
1257 I32 optype;
1258 SV **mark;
1259 SV **sp;
1260 {
1261     SV *astr;
1262     char *a;
1263     I32 id, n, cmd, infosize, getinfo;
1264     I32 ret = -1;
1265
1266     id = SvIVx(*++mark);
1267     n = (optype == OP_SEMCTL) ? SvIVx(*++mark) : 0;
1268     cmd = SvIVx(*++mark);
1269     astr = *++mark;
1270     infosize = 0;
1271     getinfo = (cmd == IPC_STAT);
1272
1273     switch (optype)
1274     {
1275 #ifdef HAS_MSG
1276     case OP_MSGCTL:
1277         if (cmd == IPC_STAT || cmd == IPC_SET)
1278             infosize = sizeof(struct msqid_ds);
1279         break;
1280 #endif
1281 #ifdef HAS_SHM
1282     case OP_SHMCTL:
1283         if (cmd == IPC_STAT || cmd == IPC_SET)
1284             infosize = sizeof(struct shmid_ds);
1285         break;
1286 #endif
1287 #ifdef HAS_SEM
1288     case OP_SEMCTL:
1289         if (cmd == IPC_STAT || cmd == IPC_SET)
1290             infosize = sizeof(struct semid_ds);
1291         else if (cmd == GETALL || cmd == SETALL)
1292         {
1293             struct semid_ds semds;
1294             if (semctl(id, 0, IPC_STAT, &semds) == -1)
1295                 return -1;
1296             getinfo = (cmd == GETALL);
1297             infosize = semds.sem_nsems * sizeof(short);
1298                 /* "short" is technically wrong but much more portable
1299                    than guessing about u_?short(_t)? */
1300         }
1301         break;
1302 #endif
1303 #if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
1304     default:
1305         croak("%s not implemented", op_name[optype]);
1306 #endif
1307     }
1308
1309     if (infosize)
1310     {
1311         STRLEN len;
1312         if (getinfo)
1313         {
1314             SvPV_force(astr, len);
1315             a = SvGROW(astr, infosize+1);
1316         }
1317         else
1318         {
1319             a = SvPV(astr, len);
1320             if (len != infosize)
1321                 croak("Bad arg length for %s, is %d, should be %d",
1322                         op_name[optype], len, infosize);
1323         }
1324     }
1325     else
1326     {
1327         I32 i = SvIV(astr);
1328         a = (char *)i;          /* ouch */
1329     }
1330     SETERRNO(0,0);
1331     switch (optype)
1332     {
1333 #ifdef HAS_MSG
1334     case OP_MSGCTL:
1335         ret = msgctl(id, cmd, (struct msqid_ds *)a);
1336         break;
1337 #endif
1338 #ifdef HAS_SEM
1339     case OP_SEMCTL:
1340         ret = semctl(id, n, cmd, (struct semid_ds *)a);
1341         break;
1342 #endif
1343 #ifdef HAS_SHM
1344     case OP_SHMCTL:
1345         ret = shmctl(id, cmd, (struct shmid_ds *)a);
1346         break;
1347 #endif
1348     }
1349     if (getinfo && ret >= 0) {
1350         SvCUR_set(astr, infosize);
1351         *SvEND(astr) = '\0';
1352         SvSETMAGIC(astr);
1353     }
1354     return ret;
1355 }
1356
1357 I32
1358 do_msgsnd(mark, sp)
1359 SV **mark;
1360 SV **sp;
1361 {
1362 #ifdef HAS_MSG
1363     SV *mstr;
1364     char *mbuf;
1365     I32 id, msize, flags;
1366     STRLEN len;
1367
1368     id = SvIVx(*++mark);
1369     mstr = *++mark;
1370     flags = SvIVx(*++mark);
1371     mbuf = SvPV(mstr, len);
1372     if ((msize = len - sizeof(long)) < 0)
1373         croak("Arg too short for msgsnd");
1374     SETERRNO(0,0);
1375     return msgsnd(id, (struct msgbuf *)mbuf, msize, flags);
1376 #else
1377     croak("msgsnd not implemented");
1378 #endif
1379 }
1380
1381 I32
1382 do_msgrcv(mark, sp)
1383 SV **mark;
1384 SV **sp;
1385 {
1386 #ifdef HAS_MSG
1387     SV *mstr;
1388     char *mbuf;
1389     long mtype;
1390     I32 id, msize, flags, ret;
1391     STRLEN len;
1392
1393     id = SvIVx(*++mark);
1394     mstr = *++mark;
1395     msize = SvIVx(*++mark);
1396     mtype = (long)SvIVx(*++mark);
1397     flags = SvIVx(*++mark);
1398     if (SvTHINKFIRST(mstr)) {
1399         if (SvREADONLY(mstr))
1400             croak("Can't msgrcv to readonly var");
1401         if (SvROK(mstr))
1402             sv_unref(mstr);
1403     }
1404     SvPV_force(mstr, len);
1405     mbuf = SvGROW(mstr, sizeof(long)+msize+1);
1406
1407     SETERRNO(0,0);
1408     ret = msgrcv(id, (struct msgbuf *)mbuf, msize, mtype, flags);
1409     if (ret >= 0) {
1410         SvCUR_set(mstr, sizeof(long)+ret);
1411         *SvEND(mstr) = '\0';
1412     }
1413     return ret;
1414 #else
1415     croak("msgrcv not implemented");
1416 #endif
1417 }
1418
1419 I32
1420 do_semop(mark, sp)
1421 SV **mark;
1422 SV **sp;
1423 {
1424 #ifdef HAS_SEM
1425     SV *opstr;
1426     char *opbuf;
1427     I32 id;
1428     STRLEN opsize;
1429
1430     id = SvIVx(*++mark);
1431     opstr = *++mark;
1432     opbuf = SvPV(opstr, opsize);
1433     if (opsize < sizeof(struct sembuf)
1434         || (opsize % sizeof(struct sembuf)) != 0) {
1435         SETERRNO(EINVAL,LIB$_INVARG);
1436         return -1;
1437     }
1438     SETERRNO(0,0);
1439     return semop(id, (struct sembuf *)opbuf, opsize/sizeof(struct sembuf));
1440 #else
1441     croak("semop not implemented");
1442 #endif
1443 }
1444
1445 I32
1446 do_shmio(optype, mark, sp)
1447 I32 optype;
1448 SV **mark;
1449 SV **sp;
1450 {
1451 #ifdef HAS_SHM
1452     SV *mstr;
1453     char *mbuf, *shm;
1454     I32 id, mpos, msize;
1455     STRLEN len;
1456     struct shmid_ds shmds;
1457
1458     id = SvIVx(*++mark);
1459     mstr = *++mark;
1460     mpos = SvIVx(*++mark);
1461     msize = SvIVx(*++mark);
1462     SETERRNO(0,0);
1463     if (shmctl(id, IPC_STAT, &shmds) == -1)
1464         return -1;
1465     if (mpos < 0 || msize < 0 || mpos + msize > shmds.shm_segsz) {
1466         SETERRNO(EFAULT,SS$_ACCVIO);            /* can't do as caller requested */
1467         return -1;
1468     }
1469     shm = (Shmat_t)shmat(id, (char*)NULL, (optype == OP_SHMREAD) ? SHM_RDONLY : 0);
1470     if (shm == (char *)-1)      /* I hate System V IPC, I really do */
1471         return -1;
1472     if (optype == OP_SHMREAD) {
1473         SvPV_force(mstr, len);
1474         mbuf = SvGROW(mstr, msize+1);
1475
1476         Copy(shm + mpos, mbuf, msize, char);
1477         SvCUR_set(mstr, msize);
1478         *SvEND(mstr) = '\0';
1479         SvSETMAGIC(mstr);
1480     }
1481     else {
1482         I32 n;
1483
1484         mbuf = SvPV(mstr, len);
1485         if ((n = len) > msize)
1486             n = msize;
1487         Copy(mbuf, shm + mpos, n, char);
1488         if (n < msize)
1489             memzero(shm + mpos + n, msize - n);
1490     }
1491     return shmdt(shm);
1492 #else
1493     croak("shm I/O not implemented");
1494 #endif
1495 }
1496
1497 #endif /* SYSV IPC */