perl 4.0 patch 2: Patch 1 continued
[perl.git] / doio.c
1 /* $RCSfile: doio.c,v $$Revision: 4.0.1.1 $$Date: 91/04/11 17:41:06 $
2  *
3  *    Copyright (c) 1989, Larry Wall
4  *
5  *    You may distribute under the terms of the GNU General Public License
6  *    as specified in the README file that comes with the perl 3.0 kit.
7  *
8  * $Log:        doio.c,v $
9  * Revision 4.0.1.1  91/04/11  17:41:06  lwall
10  * patch1: hopefully straightened out some of the Xenix mess
11  * 
12  * Revision 4.0  91/03/20  01:07:06  lwall
13  * 4.0 baseline.
14  * 
15  */
16
17 #include "EXTERN.h"
18 #include "perl.h"
19
20 #ifdef HAS_SOCKET
21 #include <sys/socket.h>
22 #include <netdb.h>
23 #endif
24
25 #ifdef HAS_SELECT
26 #ifdef I_SYS_SELECT
27 #ifndef I_SYS_TIME
28 #include <sys/select.h>
29 #endif
30 #endif
31 #endif
32
33 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
34 #include <sys/ipc.h>
35 #ifdef HAS_MSG
36 #include <sys/msg.h>
37 #endif
38 #ifdef HAS_SEM
39 #include <sys/sem.h>
40 #endif
41 #ifdef HAS_SHM
42 #include <sys/shm.h>
43 #endif
44 #endif
45
46 #ifdef I_PWD
47 #include <pwd.h>
48 #endif
49 #ifdef I_GRP
50 #include <grp.h>
51 #endif
52 #ifdef I_UTIME
53 #include <utime.h>
54 #endif
55 #ifdef I_FCNTL
56 #include <fcntl.h>
57 #endif
58 #ifdef I_SYS_FILE
59 #include <sys/file.h>
60 #endif
61
62 int laststatval = -1;
63 int laststype = O_STAT;
64
65 bool
66 do_open(stab,name,len)
67 STAB *stab;
68 register char *name;
69 int len;
70 {
71     FILE *fp;
72     register STIO *stio = stab_io(stab);
73     char *myname = savestr(name);
74     int result;
75     int fd;
76     int writing = 0;
77     char mode[3];               /* stdio file mode ("r\0" or "r+\0") */
78
79     name = myname;
80     forkprocess = 1;            /* assume true if no fork */
81     while (len && isspace(name[len-1]))
82         name[--len] = '\0';
83     if (!stio)
84         stio = stab_io(stab) = stio_new();
85     else if (stio->ifp) {
86         fd = fileno(stio->ifp);
87         if (stio->type == '|')
88             result = mypclose(stio->ifp);
89         else if (stio->type == '-')
90             result = 0;
91         else if (stio->ifp != stio->ofp) {
92             if (stio->ofp) {
93                 result = fclose(stio->ofp);
94                 fclose(stio->ifp);      /* clear stdio, fd already closed */
95             }
96             else
97                 result = fclose(stio->ifp);
98         }
99         else
100             result = fclose(stio->ifp);
101         if (result == EOF && fd > 2)
102             fprintf(stderr,"Warning: unable to close filehandle %s properly.\n",
103               stab_name(stab));
104         stio->ofp = stio->ifp = Nullfp;
105     }
106     if (*name == '+' && len > 1 && name[len-1] != '|') {        /* scary */
107         mode[1] = *name++;
108         mode[2] = '\0';
109         --len;
110         writing = 1;
111     }
112     else  {
113         mode[1] = '\0';
114     }
115     stio->type = *name;
116     if (*name == '|') {
117         for (name++; isspace(*name); name++) ;
118 #ifdef TAINT
119         taintenv();
120         taintproper("Insecure dependency in piped open");
121 #endif
122         fp = mypopen(name,"w");
123         writing = 1;
124     }
125     else if (*name == '>') {
126 #ifdef TAINT
127         taintproper("Insecure dependency in open");
128 #endif
129         name++;
130         if (*name == '>') {
131             mode[0] = stio->type = 'a';
132             name++;
133         }
134         else
135             mode[0] = 'w';
136         writing = 1;
137         if (*name == '&') {
138           duplicity:
139             name++;
140             while (isspace(*name))
141                 name++;
142             if (isdigit(*name))
143                 fd = atoi(name);
144             else {
145                 stab = stabent(name,FALSE);
146                 if (!stab || !stab_io(stab))
147                     return FALSE;
148                 if (stab_io(stab) && stab_io(stab)->ifp) {
149                     fd = fileno(stab_io(stab)->ifp);
150                     if (stab_io(stab)->type == 's')
151                         stio->type = 's';
152                 }
153                 else
154                     fd = -1;
155             }
156             if (!(fp = fdopen(fd = dup(fd),mode))) {
157                 close(fd);
158             }
159         }
160         else {
161             while (isspace(*name))
162                 name++;
163             if (strEQ(name,"-")) {
164                 fp = stdout;
165                 stio->type = '-';
166             }
167             else  {
168                 fp = fopen(name,mode);
169             }
170         }
171     }
172     else {
173         if (*name == '<') {
174             mode[0] = 'r';
175             name++;
176             while (isspace(*name))
177                 name++;
178             if (*name == '&')
179                 goto duplicity;
180             if (strEQ(name,"-")) {
181                 fp = stdin;
182                 stio->type = '-';
183             }
184             else
185                 fp = fopen(name,mode);
186         }
187         else if (name[len-1] == '|') {
188 #ifdef TAINT
189             taintenv();
190             taintproper("Insecure dependency in piped open");
191 #endif
192             name[--len] = '\0';
193             while (len && isspace(name[len-1]))
194                 name[--len] = '\0';
195             for (; isspace(*name); name++) ;
196             fp = mypopen(name,"r");
197             stio->type = '|';
198         }
199         else {
200             stio->type = '<';
201             for (; isspace(*name); name++) ;
202             if (strEQ(name,"-")) {
203                 fp = stdin;
204                 stio->type = '-';
205             }
206             else
207                 fp = fopen(name,"r");
208         }
209     }
210     Safefree(myname);
211     if (!fp)
212         return FALSE;
213     if (stio->type &&
214       stio->type != '|' && stio->type != '-') {
215         if (fstat(fileno(fp),&statbuf) < 0) {
216             (void)fclose(fp);
217             return FALSE;
218         }
219         if (S_ISSOCK(statbuf.st_mode))
220             stio->type = 's';   /* in case a socket was passed in to us */
221 #ifdef S_IFMT
222         else if (!(statbuf.st_mode & S_IFMT))
223             stio->type = 's';   /* some OS's return 0 on fstat()ed socket */
224 #endif
225     }
226 #if defined(HAS_FCNTL) && defined(F_SETFD)
227     fd = fileno(fp);
228     fcntl(fd,F_SETFD,fd >= 3);
229 #endif
230     stio->ifp = fp;
231     if (writing) {
232         if (stio->type != 's')
233             stio->ofp = fp;
234         else
235             if (!(stio->ofp = fdopen(fileno(fp),"w"))) {
236                 fclose(fp);
237                 stio->ifp = Nullfp;
238             }
239     }
240     return TRUE;
241 }
242
243 FILE *
244 nextargv(stab)
245 register STAB *stab;
246 {
247     register STR *str;
248     int filedev;
249     int fileino;
250     int fileuid;
251     int filegid;
252     static int filemode = 0;
253     static int lastfd;
254     static char *oldname;
255
256     if (!argvoutstab)
257         argvoutstab = stabent("ARGVOUT",TRUE);
258     if (filemode & (S_ISUID|S_ISGID)) {
259         fflush(stab_io(argvoutstab)->ifp);  /* chmod must follow last write */
260 #ifdef HAS_FCHMOD
261         (void)fchmod(lastfd,filemode);
262 #else
263         (void)chmod(oldname,filemode);
264 #endif
265     }
266     filemode = 0;
267     while (alen(stab_xarray(stab)) >= 0) {
268         str = ashift(stab_xarray(stab));
269         str_sset(stab_val(stab),str);
270         STABSET(stab_val(stab));
271         oldname = str_get(stab_val(stab));
272         if (do_open(stab,oldname,stab_val(stab)->str_cur)) {
273             if (inplace) {
274 #ifdef TAINT
275                 taintproper("Insecure dependency in inplace open");
276 #endif
277                 if (strEQ(oldname,"-")) {
278                     str_free(str);
279                     defoutstab = stabent("STDOUT",TRUE);
280                     return stab_io(stab)->ifp;
281                 }
282                 filedev = statbuf.st_dev;
283                 fileino = statbuf.st_ino;
284                 filemode = statbuf.st_mode;
285                 fileuid = statbuf.st_uid;
286                 filegid = statbuf.st_gid;
287                 if (!S_ISREG(filemode)) {
288                     warn("Can't do inplace edit: %s is not a regular file",
289                       oldname );
290                     do_close(stab,FALSE);
291                     str_free(str);
292                     continue;
293                 }
294                 if (*inplace) {
295 #ifdef SUFFIX
296                     add_suffix(str,inplace);
297 #else
298                     str_cat(str,inplace);
299 #endif
300 #ifndef FLEXFILENAMES
301                     if (stat(str->str_ptr,&statbuf) >= 0
302                       && statbuf.st_dev == filedev
303                       && statbuf.st_ino == fileino ) {
304                         warn("Can't do inplace edit: %s > 14 characters",
305                           str->str_ptr );
306                         do_close(stab,FALSE);
307                         str_free(str);
308                         continue;
309                     }
310 #endif
311 #ifdef HAS_RENAME
312 #ifndef MSDOS
313                     if (rename(oldname,str->str_ptr) < 0) {
314                         warn("Can't rename %s to %s: %s, skipping file",
315                           oldname, str->str_ptr, strerror(errno) );
316                         do_close(stab,FALSE);
317                         str_free(str);
318                         continue;
319                     }
320 #else
321                     do_close(stab,FALSE);
322                     (void)unlink(str->str_ptr);
323                     (void)rename(oldname,str->str_ptr);
324                     do_open(stab,str->str_ptr,stab_val(stab)->str_cur);
325 #endif /* MSDOS */
326 #else
327                     (void)UNLINK(str->str_ptr);
328                     if (link(oldname,str->str_ptr) < 0) {
329                         warn("Can't rename %s to %s: %s, skipping file",
330                           oldname, str->str_ptr, strerror(errno) );
331                         do_close(stab,FALSE);
332                         str_free(str);
333                         continue;
334                     }
335                     (void)UNLINK(oldname);
336 #endif
337                 }
338                 else {
339 #ifndef MSDOS
340                     if (UNLINK(oldname) < 0) {
341                         warn("Can't rename %s to %s: %s, skipping file",
342                           oldname, str->str_ptr, strerror(errno) );
343                         do_close(stab,FALSE);
344                         str_free(str);
345                         continue;
346                     }
347 #else
348                     fatal("Can't do inplace edit without backup");
349 #endif
350                 }
351
352                 str_nset(str,">",1);
353                 str_cat(str,oldname);
354                 errno = 0;              /* in case sprintf set errno */
355                 if (!do_open(argvoutstab,str->str_ptr,str->str_cur)) {
356                     warn("Can't do inplace edit on %s: %s",
357                       oldname, strerror(errno) );
358                     do_close(stab,FALSE);
359                     str_free(str);
360                     continue;
361                 }
362                 defoutstab = argvoutstab;
363                 lastfd = fileno(stab_io(argvoutstab)->ifp);
364                 (void)fstat(lastfd,&statbuf);
365 #ifdef HAS_FCHMOD
366                 (void)fchmod(lastfd,filemode);
367 #else
368                 (void)chmod(oldname,filemode);
369 #endif
370                 if (fileuid != statbuf.st_uid || filegid != statbuf.st_gid) {
371 #ifdef HAS_FCHOWN
372                     (void)fchown(lastfd,fileuid,filegid);
373 #else
374 #ifdef HAS_CHOWN
375                     (void)chown(oldname,fileuid,filegid);
376 #endif
377 #endif
378                 }
379             }
380             str_free(str);
381             return stab_io(stab)->ifp;
382         }
383         else
384             fprintf(stderr,"Can't open %s: %s\n",str_get(str), strerror(errno));
385         str_free(str);
386     }
387     if (inplace) {
388         (void)do_close(argvoutstab,FALSE);
389         defoutstab = stabent("STDOUT",TRUE);
390     }
391     return Nullfp;
392 }
393
394 #ifdef HAS_PIPE
395 void
396 do_pipe(str, rstab, wstab)
397 STR *str;
398 STAB *rstab;
399 STAB *wstab;
400 {
401     register STIO *rstio;
402     register STIO *wstio;
403     int fd[2];
404
405     if (!rstab)
406         goto badexit;
407     if (!wstab)
408         goto badexit;
409
410     rstio = stab_io(rstab);
411     wstio = stab_io(wstab);
412
413     if (!rstio)
414         rstio = stab_io(rstab) = stio_new();
415     else if (rstio->ifp)
416         do_close(rstab,FALSE);
417     if (!wstio)
418         wstio = stab_io(wstab) = stio_new();
419     else if (wstio->ifp)
420         do_close(wstab,FALSE);
421
422     if (pipe(fd) < 0)
423         goto badexit;
424     rstio->ifp = fdopen(fd[0], "r");
425     wstio->ofp = fdopen(fd[1], "w");
426     wstio->ifp = wstio->ofp;
427     rstio->type = '<';
428     wstio->type = '>';
429     if (!rstio->ifp || !wstio->ofp) {
430         if (rstio->ifp) fclose(rstio->ifp);
431         else close(fd[0]);
432         if (wstio->ofp) fclose(wstio->ofp);
433         else close(fd[1]);
434         goto badexit;
435     }
436
437     str_sset(str,&str_yes);
438     return;
439
440 badexit:
441     str_sset(str,&str_undef);
442     return;
443 }
444 #endif
445
446 bool
447 do_close(stab,explicit)
448 STAB *stab;
449 bool explicit;
450 {
451     bool retval = FALSE;
452     register STIO *stio;
453     int status;
454
455     if (!stab)
456         stab = argvstab;
457     if (!stab)
458         return FALSE;
459     stio = stab_io(stab);
460     if (!stio) {                /* never opened */
461         if (dowarn && explicit)
462             warn("Close on unopened file <%s>",stab_name(stab));
463         return FALSE;
464     }
465     if (stio->ifp) {
466         if (stio->type == '|') {
467             status = mypclose(stio->ifp);
468             retval = (status == 0);
469             statusvalue = (unsigned short)status & 0xffff;
470         }
471         else if (stio->type == '-')
472             retval = TRUE;
473         else {
474             if (stio->ofp && stio->ofp != stio->ifp) {          /* a socket */
475                 retval = (fclose(stio->ofp) != EOF);
476                 fclose(stio->ifp);      /* clear stdio, fd already closed */
477             }
478             else
479                 retval = (fclose(stio->ifp) != EOF);
480         }
481         stio->ofp = stio->ifp = Nullfp;
482     }
483     if (explicit)
484         stio->lines = 0;
485     stio->type = ' ';
486     return retval;
487 }
488
489 bool
490 do_eof(stab)
491 STAB *stab;
492 {
493     register STIO *stio;
494     int ch;
495
496     if (!stab) {                        /* eof() */
497         if (argvstab)
498             stio = stab_io(argvstab);
499         else
500             return TRUE;
501     }
502     else
503         stio = stab_io(stab);
504
505     if (!stio)
506         return TRUE;
507
508     while (stio->ifp) {
509
510 #ifdef STDSTDIO                 /* (the code works without this) */
511         if (stio->ifp->_cnt > 0)        /* cheat a little, since */
512             return FALSE;               /* this is the most usual case */
513 #endif
514
515         ch = getc(stio->ifp);
516         if (ch != EOF) {
517             (void)ungetc(ch, stio->ifp);
518             return FALSE;
519         }
520 #ifdef STDSTDIO
521         if (stio->ifp->_cnt < -1)
522             stio->ifp->_cnt = -1;
523 #endif
524         if (!stab) {                    /* not necessarily a real EOF yet? */
525             if (!nextargv(argvstab))    /* get another fp handy */
526                 return TRUE;
527         }
528         else
529             return TRUE;                /* normal fp, definitely end of file */
530     }
531     return TRUE;
532 }
533
534 long
535 do_tell(stab)
536 STAB *stab;
537 {
538     register STIO *stio;
539
540     if (!stab)
541         goto phooey;
542
543     stio = stab_io(stab);
544     if (!stio || !stio->ifp)
545         goto phooey;
546
547     if (feof(stio->ifp))
548         (void)fseek (stio->ifp, 0L, 2);         /* ultrix 1.2 workaround */
549
550     return ftell(stio->ifp);
551
552 phooey:
553     if (dowarn)
554         warn("tell() on unopened file");
555     return -1L;
556 }
557
558 bool
559 do_seek(stab, pos, whence)
560 STAB *stab;
561 long pos;
562 int whence;
563 {
564     register STIO *stio;
565
566     if (!stab)
567         goto nuts;
568
569     stio = stab_io(stab);
570     if (!stio || !stio->ifp)
571         goto nuts;
572
573     if (feof(stio->ifp))
574         (void)fseek (stio->ifp, 0L, 2);         /* ultrix 1.2 workaround */
575
576     return fseek(stio->ifp, pos, whence) >= 0;
577
578 nuts:
579     if (dowarn)
580         warn("seek() on unopened file");
581     return FALSE;
582 }
583
584 int
585 do_ctl(optype,stab,func,argstr)
586 int optype;
587 STAB *stab;
588 int func;
589 STR *argstr;
590 {
591     register STIO *stio;
592     register char *s;
593     int retval;
594
595     if (!stab || !argstr)
596         return -1;
597     stio = stab_io(stab);
598     if (!stio)
599         return -1;
600
601     if (argstr->str_pok || !argstr->str_nok) {
602         if (!argstr->str_pok)
603             s = str_get(argstr);
604
605 #ifdef IOCPARM_MASK
606 #ifndef IOCPARM_LEN
607 #define IOCPARM_LEN(x)  (((x) >> 16) & IOCPARM_MASK)
608 #endif
609 #endif
610 #ifdef IOCPARM_LEN
611         retval = IOCPARM_LEN(func);     /* on BSDish systes we're safe */
612 #else
613         retval = 256;                   /* otherwise guess at what's safe */
614 #endif
615         if (argstr->str_cur < retval) {
616             Str_Grow(argstr,retval+1);
617             argstr->str_cur = retval;
618         }
619
620         s = argstr->str_ptr;
621         s[argstr->str_cur] = 17;        /* a little sanity check here */
622     }
623     else {
624         retval = (int)str_gnum(argstr);
625 #ifdef MSDOS
626         s = (char*)(long)retval;                /* ouch */
627 #else
628         s = (char*)retval;              /* ouch */
629 #endif
630     }
631
632 #ifndef lint
633     if (optype == O_IOCTL)
634         retval = ioctl(fileno(stio->ifp), func, s);
635     else
636 #ifdef MSDOS
637         fatal("fcntl is not implemented");
638 #else
639 #ifdef HAS_FCNTL
640         retval = fcntl(fileno(stio->ifp), func, s);
641 #else
642         fatal("fcntl is not implemented");
643 #endif
644 #endif
645 #else /* lint */
646     retval = 0;
647 #endif /* lint */
648
649     if (argstr->str_pok) {
650         if (s[argstr->str_cur] != 17)
651             fatal("Return value overflowed string");
652         s[argstr->str_cur] = 0;         /* put our null back */
653     }
654     return retval;
655 }
656
657 int
658 do_stat(str,arg,gimme,arglast)
659 STR *str;
660 register ARG *arg;
661 int gimme;
662 int *arglast;
663 {
664     register ARRAY *ary = stack;
665     register int sp = arglast[0] + 1;
666     int max = 13;
667
668     if ((arg[1].arg_type & A_MASK) == A_WORD) {
669         tmpstab = arg[1].arg_ptr.arg_stab;
670         if (tmpstab != defstab) {
671             laststype = O_STAT;
672             statstab = tmpstab;
673             str_set(statname,"");
674             if (!stab_io(tmpstab) || !stab_io(tmpstab)->ifp ||
675               fstat(fileno(stab_io(tmpstab)->ifp),&statcache) < 0) {
676                 max = 0;
677                 laststatval = -1;
678             }
679         }
680         else if (laststatval < 0)
681             max = 0;
682     }
683     else {
684         str_set(statname,str_get(ary->ary_array[sp]));
685         statstab = Nullstab;
686 #ifdef HAS_LSTAT
687         laststype = arg->arg_type;
688         if (arg->arg_type == O_LSTAT)
689             laststatval = lstat(str_get(statname),&statcache);
690         else
691 #endif
692             laststatval = stat(str_get(statname),&statcache);
693         if (laststatval < 0)
694             max = 0;
695     }
696
697     if (gimme != G_ARRAY) {
698         if (max)
699             str_sset(str,&str_yes);
700         else
701             str_sset(str,&str_undef);
702         STABSET(str);
703         ary->ary_array[sp] = str;
704         return sp;
705     }
706     sp--;
707     if (max) {
708 #ifndef lint
709         (void)astore(ary,++sp,
710           str_2mortal(str_nmake((double)statcache.st_dev)));
711         (void)astore(ary,++sp,
712           str_2mortal(str_nmake((double)statcache.st_ino)));
713         (void)astore(ary,++sp,
714           str_2mortal(str_nmake((double)statcache.st_mode)));
715         (void)astore(ary,++sp,
716           str_2mortal(str_nmake((double)statcache.st_nlink)));
717         (void)astore(ary,++sp,
718           str_2mortal(str_nmake((double)statcache.st_uid)));
719         (void)astore(ary,++sp,
720           str_2mortal(str_nmake((double)statcache.st_gid)));
721         (void)astore(ary,++sp,
722           str_2mortal(str_nmake((double)statcache.st_rdev)));
723         (void)astore(ary,++sp,
724           str_2mortal(str_nmake((double)statcache.st_size)));
725         (void)astore(ary,++sp,
726           str_2mortal(str_nmake((double)statcache.st_atime)));
727         (void)astore(ary,++sp,
728           str_2mortal(str_nmake((double)statcache.st_mtime)));
729         (void)astore(ary,++sp,
730           str_2mortal(str_nmake((double)statcache.st_ctime)));
731 #ifdef STATBLOCKS
732         (void)astore(ary,++sp,
733           str_2mortal(str_nmake((double)statcache.st_blksize)));
734         (void)astore(ary,++sp,
735           str_2mortal(str_nmake((double)statcache.st_blocks)));
736 #else
737         (void)astore(ary,++sp,
738           str_2mortal(str_make("",0)));
739         (void)astore(ary,++sp,
740           str_2mortal(str_make("",0)));
741 #endif
742 #else /* lint */
743         (void)astore(ary,++sp,str_nmake(0.0));
744 #endif /* lint */
745     }
746     return sp;
747 }
748
749 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
750         /* code courtesy of William Kucharski */
751 #define HAS_CHSIZE
752
753 int chsize(fd, length)
754 int fd;                 /* file descriptor */
755 off_t length;           /* length to set file to */
756 {
757     extern long lseek();
758     struct flock fl;
759     struct stat filebuf;
760
761     if (fstat(fd, &filebuf) < 0)
762         return -1;
763
764     if (filebuf.st_size < length) {
765
766         /* extend file length */
767
768         if ((lseek(fd, (length - 1), 0)) < 0)
769             return -1;
770
771         /* write a "0" byte */
772
773         if ((write(fd, "", 1)) != 1)
774             return -1;
775     }
776     else {
777         /* truncate length */
778
779         fl.l_whence = 0;
780         fl.l_len = 0;
781         fl.l_start = length;
782         fl.l_type = F_WRLCK;    /* write lock on file space */
783
784         /*
785         * This relies on the UNDOCUMENTED F_FREESP argument to
786         * fcntl(2), which truncates the file so that it ends at the
787         * position indicated by fl.l_start.
788         *
789         * Will minor miracles never cease?
790         */
791
792         if (fcntl(fd, F_FREESP, &fl) < 0)
793             return -1;
794
795     }
796
797     return 0;
798 }
799 #endif /* F_FREESP */
800
801 int
802 do_truncate(str,arg,gimme,arglast)
803 STR *str;
804 register ARG *arg;
805 int gimme;
806 int *arglast;
807 {
808     register ARRAY *ary = stack;
809     register int sp = arglast[0] + 1;
810     off_t len = (off_t)str_gnum(ary->ary_array[sp+1]);
811     int result = 1;
812     STAB *tmpstab;
813
814 #if defined(HAS_TRUNCATE) || defined(HAS_CHSIZE)
815 #ifdef HAS_TRUNCATE
816     if ((arg[1].arg_type & A_MASK) == A_WORD) {
817         tmpstab = arg[1].arg_ptr.arg_stab;
818         if (!stab_io(tmpstab) ||
819           ftruncate(fileno(stab_io(tmpstab)->ifp), len) < 0)
820             result = 0;
821     }
822     else if (truncate(str_get(ary->ary_array[sp]), len) < 0)
823         result = 0;
824 #else
825     if ((arg[1].arg_type & A_MASK) == A_WORD) {
826         tmpstab = arg[1].arg_ptr.arg_stab;
827         if (!stab_io(tmpstab) ||
828           chsize(fileno(stab_io(tmpstab)->ifp), len) < 0)
829             result = 0;
830     }
831     else {
832         int tmpfd;
833
834         if ((tmpfd = open(str_get(ary->ary_array[sp]), 0)) < 0)
835             result = 0;
836         else {
837             if (chsize(tmpfd, len) < 0)
838                 result = 0;
839             close(tmpfd);
840         }
841     }
842 #endif
843
844     if (result)
845         str_sset(str,&str_yes);
846     else
847         str_sset(str,&str_undef);
848     STABSET(str);
849     ary->ary_array[sp] = str;
850     return sp;
851 #else
852     fatal("truncate not implemented");
853 #endif
854 }
855
856 int
857 looks_like_number(str)
858 STR *str;
859 {
860     register char *s;
861     register char *send;
862
863     if (!str->str_pok)
864         return TRUE;
865     s = str->str_ptr; 
866     send = s + str->str_cur;
867     while (isspace(*s))
868         s++;
869     if (s >= send)
870         return FALSE;
871     if (*s == '+' || *s == '-')
872         s++;
873     while (isdigit(*s))
874         s++;
875     if (s == send)
876         return TRUE;
877     if (*s == '.') 
878         s++;
879     else if (s == str->str_ptr)
880         return FALSE;
881     while (isdigit(*s))
882         s++;
883     if (s == send)
884         return TRUE;
885     if (*s == 'e' || *s == 'E') {
886         s++;
887         if (*s == '+' || *s == '-')
888             s++;
889         while (isdigit(*s))
890             s++;
891     }
892     while (isspace(*s))
893         s++;
894     if (s >= send)
895         return TRUE;
896     return FALSE;
897 }
898
899 bool
900 do_print(str,fp)
901 register STR *str;
902 FILE *fp;
903 {
904     register char *tmps;
905
906     if (!fp) {
907         if (dowarn)
908             warn("print to unopened file");
909         return FALSE;
910     }
911     if (!str)
912         return TRUE;
913     if (ofmt &&
914       ((str->str_nok && str->str_u.str_nval != 0.0)
915        || (looks_like_number(str) && str_gnum(str) != 0.0) ) ) {
916         fprintf(fp, ofmt, str->str_u.str_nval);
917         return !ferror(fp);
918     }
919     else {
920         tmps = str_get(str);
921         if (*tmps == 'S' && tmps[1] == 't' && tmps[2] == 'B' && tmps[3] == '\0'
922           && str->str_cur == sizeof(STBP) && strlen(tmps) < str->str_cur) {
923             STR *tmpstr = str_mortal(&str_undef);
924             stab_fullname(tmpstr,((STAB*)str));/* a stab value, be nice */
925             str = tmpstr;
926             tmps = str->str_ptr;
927             putc('*',fp);
928         }
929         if (str->str_cur && (fwrite(tmps,1,str->str_cur,fp) == 0 || ferror(fp)))
930             return FALSE;
931     }
932     return TRUE;
933 }
934
935 bool
936 do_aprint(arg,fp,arglast)
937 register ARG *arg;
938 register FILE *fp;
939 int *arglast;
940 {
941     register STR **st = stack->ary_array;
942     register int sp = arglast[1];
943     register int retval;
944     register int items = arglast[2] - sp;
945
946     if (!fp) {
947         if (dowarn)
948             warn("print to unopened file");
949         return FALSE;
950     }
951     st += ++sp;
952     if (arg->arg_type == O_PRTF) {
953         do_sprintf(arg->arg_ptr.arg_str,items,st);
954         retval = do_print(arg->arg_ptr.arg_str,fp);
955     }
956     else {
957         retval = (items <= 0);
958         for (; items > 0; items--,st++) {
959             if (retval && ofslen) {
960                 if (fwrite(ofs, 1, ofslen, fp) == 0 || ferror(fp)) {
961                     retval = FALSE;
962                     break;
963                 }
964             }
965             if (!(retval = do_print(*st, fp)))
966                 break;
967         }
968         if (retval && orslen)
969             if (fwrite(ors, 1, orslen, fp) == 0 || ferror(fp))
970                 retval = FALSE;
971     }
972     return retval;
973 }
974
975 int
976 mystat(arg,str)
977 ARG *arg;
978 STR *str;
979 {
980     STIO *stio;
981
982     laststype = O_STAT;
983     if (arg[1].arg_type & A_DONT) {
984         stio = stab_io(arg[1].arg_ptr.arg_stab);
985         if (stio && stio->ifp) {
986             statstab = arg[1].arg_ptr.arg_stab;
987             str_set(statname,"");
988             return (laststatval = fstat(fileno(stio->ifp), &statcache));
989         }
990         else {
991             if (arg[1].arg_ptr.arg_stab == defstab)
992                 return laststatval;
993             if (dowarn)
994                 warn("Stat on unopened file <%s>",
995                   stab_name(arg[1].arg_ptr.arg_stab));
996             statstab = Nullstab;
997             str_set(statname,"");
998             return (laststatval = -1);
999         }
1000     }
1001     else {
1002         statstab = Nullstab;
1003         str_set(statname,str_get(str));
1004         return (laststatval = stat(str_get(str),&statcache));
1005     }
1006 }
1007
1008 int
1009 mylstat(arg,str)
1010 ARG *arg;
1011 STR *str;
1012 {
1013     if (arg[1].arg_type & A_DONT) {
1014         if (arg[1].arg_ptr.arg_stab == defstab) {
1015             if (laststype != O_LSTAT)
1016                 fatal("The stat preceding -l _ wasn't an lstat");
1017             return laststatval;
1018         }
1019         fatal("You can't use -l on a filehandle");
1020     }
1021
1022     laststype = O_LSTAT;
1023     statstab = Nullstab;
1024     str_set(statname,str_get(str));
1025 #ifdef HAS_LSTAT
1026     return (laststatval = lstat(str_get(str),&statcache));
1027 #else
1028     return (laststatval = stat(str_get(str),&statcache));
1029 #endif
1030 }
1031
1032 STR *
1033 do_fttext(arg,str)
1034 register ARG *arg;
1035 STR *str;
1036 {
1037     int i;
1038     int len;
1039     int odd = 0;
1040     STDCHAR tbuf[512];
1041     register STDCHAR *s;
1042     register STIO *stio;
1043
1044     if (arg[1].arg_type & A_DONT) {
1045         if (arg[1].arg_ptr.arg_stab == defstab) {
1046             if (statstab)
1047                 stio = stab_io(statstab);
1048             else {
1049                 str = statname;
1050                 goto really_filename;
1051             }
1052         }
1053         else {
1054             statstab = arg[1].arg_ptr.arg_stab;
1055             str_set(statname,"");
1056             stio = stab_io(statstab);
1057         }
1058         if (stio && stio->ifp) {
1059 #ifdef STDSTDIO
1060             fstat(fileno(stio->ifp),&statcache);
1061             if (stio->ifp->_cnt <= 0) {
1062                 i = getc(stio->ifp);
1063                 if (i != EOF)
1064                     (void)ungetc(i,stio->ifp);
1065             }
1066             if (stio->ifp->_cnt <= 0)   /* null file is anything */
1067                 return &str_yes;
1068             len = stio->ifp->_cnt + (stio->ifp->_ptr - stio->ifp->_base);
1069             s = stio->ifp->_base;
1070 #else
1071             fatal("-T and -B not implemented on filehandles\n");
1072 #endif
1073         }
1074         else {
1075             if (dowarn)
1076                 warn("Test on unopened file <%s>",
1077                   stab_name(arg[1].arg_ptr.arg_stab));
1078             return &str_undef;
1079         }
1080     }
1081     else {
1082         statstab = Nullstab;
1083         str_set(statname,str_get(str));
1084       really_filename:
1085         i = open(str_get(str),0);
1086         if (i < 0)
1087             return &str_undef;
1088         fstat(i,&statcache);
1089         len = read(i,tbuf,512);
1090         (void)close(i);
1091         if (len <= 0)           /* null file is anything */
1092             return &str_yes;
1093         s = tbuf;
1094     }
1095
1096     /* now scan s to look for textiness */
1097
1098     for (i = 0; i < len; i++,s++) {
1099         if (!*s) {                      /* null never allowed in text */
1100             odd += len;
1101             break;
1102         }
1103         else if (*s & 128)
1104             odd++;
1105         else if (*s < 32 &&
1106           *s != '\n' && *s != '\r' && *s != '\b' &&
1107           *s != '\t' && *s != '\f' && *s != 27)
1108             odd++;
1109     }
1110
1111     if ((odd * 10 > len) == (arg->arg_type == O_FTTEXT)) /* allow 10% odd */
1112         return &str_no;
1113     else
1114         return &str_yes;
1115 }
1116
1117 bool
1118 do_aexec(really,arglast)
1119 STR *really;
1120 int *arglast;
1121 {
1122     register STR **st = stack->ary_array;
1123     register int sp = arglast[1];
1124     register int items = arglast[2] - sp;
1125     register char **a;
1126     char **argv;
1127     char *tmps;
1128
1129     if (items) {
1130         New(401,argv, items+1, char*);
1131         a = argv;
1132         for (st += ++sp; items > 0; items--,st++) {
1133             if (*st)
1134                 *a++ = str_get(*st);
1135             else
1136                 *a++ = "";
1137         }
1138         *a = Nullch;
1139 #ifdef TAINT
1140         if (*argv[0] != '/')    /* will execvp use PATH? */
1141             taintenv();         /* testing IFS here is overkill, probably */
1142 #endif
1143         if (really && *(tmps = str_get(really)))
1144             execvp(tmps,argv);
1145         else
1146             execvp(argv[0],argv);
1147         Safefree(argv);
1148     }
1149     return FALSE;
1150 }
1151
1152 static char **Argv = Null(char **);
1153 static char *Cmd = Nullch;
1154
1155 void
1156 do_execfree()
1157 {
1158     if (Argv) {
1159         Safefree(Argv);
1160         Argv = Null(char **);
1161     }
1162     if (Cmd) {
1163         Safefree(Cmd);
1164         Cmd = Nullch;
1165     }
1166 }
1167
1168 bool
1169 do_exec(cmd)
1170 char *cmd;
1171 {
1172     register char **a;
1173     register char *s;
1174     char flags[10];
1175
1176 #ifdef TAINT
1177     taintenv();
1178     taintproper("Insecure dependency in exec");
1179 #endif
1180
1181     /* save an extra exec if possible */
1182
1183 #ifdef CSH
1184     if (strnEQ(cmd,cshname,cshlen) && strnEQ(cmd+cshlen," -c",3)) {
1185         strcpy(flags,"-c");
1186         s = cmd+cshlen+3;
1187         if (*s == 'f') {
1188             s++;
1189             strcat(flags,"f");
1190         }
1191         if (*s == ' ')
1192             s++;
1193         if (*s++ == '\'') {
1194             char *ncmd = s;
1195
1196             while (*s)
1197                 s++;
1198             if (s[-1] == '\n')
1199                 *--s = '\0';
1200             if (s[-1] == '\'') {
1201                 *--s = '\0';
1202                 execl(cshname,"csh", flags,ncmd,(char*)0);
1203                 *s = '\'';
1204                 return FALSE;
1205             }
1206         }
1207     }
1208 #endif /* CSH */
1209
1210     /* see if there are shell metacharacters in it */
1211
1212     for (s = cmd; *s && isalpha(*s); s++) ;     /* catch VAR=val gizmo */
1213     if (*s == '=')
1214         goto doshell;
1215     for (s = cmd; *s; s++) {
1216         if (*s != ' ' && !isalpha(*s) && index("$&*(){}[]'\";\\|?<>~`\n",*s)) {
1217             if (*s == '\n' && !s[1]) {
1218                 *s = '\0';
1219                 break;
1220             }
1221           doshell:
1222             execl("/bin/sh","sh","-c",cmd,(char*)0);
1223             return FALSE;
1224         }
1225     }
1226     New(402,Argv, (s - cmd) / 2 + 2, char*);
1227     Cmd = nsavestr(cmd, s-cmd);
1228     a = Argv;
1229     for (s = Cmd; *s;) {
1230         while (*s && isspace(*s)) s++;
1231         if (*s)
1232             *(a++) = s;
1233         while (*s && !isspace(*s)) s++;
1234         if (*s)
1235             *s++ = '\0';
1236     }
1237     *a = Nullch;
1238     if (Argv[0]) {
1239         execvp(Argv[0],Argv);
1240         if (errno == ENOEXEC) {         /* for system V NIH syndrome */
1241             do_execfree();
1242             goto doshell;
1243         }
1244     }
1245     do_execfree();
1246     return FALSE;
1247 }
1248
1249 #ifdef HAS_SOCKET
1250 int
1251 do_socket(stab, arglast)
1252 STAB *stab;
1253 int *arglast;
1254 {
1255     register STR **st = stack->ary_array;
1256     register int sp = arglast[1];
1257     register STIO *stio;
1258     int domain, type, protocol, fd;
1259
1260     if (!stab)
1261         return FALSE;
1262
1263     stio = stab_io(stab);
1264     if (!stio)
1265         stio = stab_io(stab) = stio_new();
1266     else if (stio->ifp)
1267         do_close(stab,FALSE);
1268
1269     domain = (int)str_gnum(st[++sp]);
1270     type = (int)str_gnum(st[++sp]);
1271     protocol = (int)str_gnum(st[++sp]);
1272 #ifdef TAINT
1273     taintproper("Insecure dependency in socket");
1274 #endif
1275     fd = socket(domain,type,protocol);
1276     if (fd < 0)
1277         return FALSE;
1278     stio->ifp = fdopen(fd, "r");        /* stdio gets confused about sockets */
1279     stio->ofp = fdopen(fd, "w");
1280     stio->type = 's';
1281     if (!stio->ifp || !stio->ofp) {
1282         if (stio->ifp) fclose(stio->ifp);
1283         if (stio->ofp) fclose(stio->ofp);
1284         if (!stio->ifp && !stio->ofp) close(fd);
1285         return FALSE;
1286     }
1287
1288     return TRUE;
1289 }
1290
1291 int
1292 do_bind(stab, arglast)
1293 STAB *stab;
1294 int *arglast;
1295 {
1296     register STR **st = stack->ary_array;
1297     register int sp = arglast[1];
1298     register STIO *stio;
1299     char *addr;
1300
1301     if (!stab)
1302         goto nuts;
1303
1304     stio = stab_io(stab);
1305     if (!stio || !stio->ifp)
1306         goto nuts;
1307
1308     addr = str_get(st[++sp]);
1309 #ifdef TAINT
1310     taintproper("Insecure dependency in bind");
1311 #endif
1312     return bind(fileno(stio->ifp), addr, st[sp]->str_cur) >= 0;
1313
1314 nuts:
1315     if (dowarn)
1316         warn("bind() on closed fd");
1317     return FALSE;
1318
1319 }
1320
1321 int
1322 do_connect(stab, arglast)
1323 STAB *stab;
1324 int *arglast;
1325 {
1326     register STR **st = stack->ary_array;
1327     register int sp = arglast[1];
1328     register STIO *stio;
1329     char *addr;
1330
1331     if (!stab)
1332         goto nuts;
1333
1334     stio = stab_io(stab);
1335     if (!stio || !stio->ifp)
1336         goto nuts;
1337
1338     addr = str_get(st[++sp]);
1339 #ifdef TAINT
1340     taintproper("Insecure dependency in connect");
1341 #endif
1342     return connect(fileno(stio->ifp), addr, st[sp]->str_cur) >= 0;
1343
1344 nuts:
1345     if (dowarn)
1346         warn("connect() on closed fd");
1347     return FALSE;
1348
1349 }
1350
1351 int
1352 do_listen(stab, arglast)
1353 STAB *stab;
1354 int *arglast;
1355 {
1356     register STR **st = stack->ary_array;
1357     register int sp = arglast[1];
1358     register STIO *stio;
1359     int backlog;
1360
1361     if (!stab)
1362         goto nuts;
1363
1364     stio = stab_io(stab);
1365     if (!stio || !stio->ifp)
1366         goto nuts;
1367
1368     backlog = (int)str_gnum(st[++sp]);
1369     return listen(fileno(stio->ifp), backlog) >= 0;
1370
1371 nuts:
1372     if (dowarn)
1373         warn("listen() on closed fd");
1374     return FALSE;
1375 }
1376
1377 void
1378 do_accept(str, nstab, gstab)
1379 STR *str;
1380 STAB *nstab;
1381 STAB *gstab;
1382 {
1383     register STIO *nstio;
1384     register STIO *gstio;
1385     int len = sizeof buf;
1386     int fd;
1387
1388     if (!nstab)
1389         goto badexit;
1390     if (!gstab)
1391         goto nuts;
1392
1393     gstio = stab_io(gstab);
1394     nstio = stab_io(nstab);
1395
1396     if (!gstio || !gstio->ifp)
1397         goto nuts;
1398     if (!nstio)
1399         nstio = stab_io(nstab) = stio_new();
1400     else if (nstio->ifp)
1401         do_close(nstab,FALSE);
1402
1403     fd = accept(fileno(gstio->ifp),buf,&len);
1404     if (fd < 0)
1405         goto badexit;
1406     nstio->ifp = fdopen(fd, "r");
1407     nstio->ofp = fdopen(fd, "w");
1408     nstio->type = 's';
1409     if (!nstio->ifp || !nstio->ofp) {
1410         if (nstio->ifp) fclose(nstio->ifp);
1411         if (nstio->ofp) fclose(nstio->ofp);
1412         if (!nstio->ifp && !nstio->ofp) close(fd);
1413         goto badexit;
1414     }
1415
1416     str_nset(str, buf, len);
1417     return;
1418
1419 nuts:
1420     if (dowarn)
1421         warn("accept() on closed fd");
1422 badexit:
1423     str_sset(str,&str_undef);
1424     return;
1425 }
1426
1427 int
1428 do_shutdown(stab, arglast)
1429 STAB *stab;
1430 int *arglast;
1431 {
1432     register STR **st = stack->ary_array;
1433     register int sp = arglast[1];
1434     register STIO *stio;
1435     int how;
1436
1437     if (!stab)
1438         goto nuts;
1439
1440     stio = stab_io(stab);
1441     if (!stio || !stio->ifp)
1442         goto nuts;
1443
1444     how = (int)str_gnum(st[++sp]);
1445     return shutdown(fileno(stio->ifp), how) >= 0;
1446
1447 nuts:
1448     if (dowarn)
1449         warn("shutdown() on closed fd");
1450     return FALSE;
1451
1452 }
1453
1454 int
1455 do_sopt(optype, stab, arglast)
1456 int optype;
1457 STAB *stab;
1458 int *arglast;
1459 {
1460     register STR **st = stack->ary_array;
1461     register int sp = arglast[1];
1462     register STIO *stio;
1463     int fd;
1464     int lvl;
1465     int optname;
1466
1467     if (!stab)
1468         goto nuts;
1469
1470     stio = stab_io(stab);
1471     if (!stio || !stio->ifp)
1472         goto nuts;
1473
1474     fd = fileno(stio->ifp);
1475     lvl = (int)str_gnum(st[sp+1]);
1476     optname = (int)str_gnum(st[sp+2]);
1477     switch (optype) {
1478     case O_GSOCKOPT:
1479         st[sp] = str_2mortal(str_new(257));
1480         st[sp]->str_cur = 256;
1481         st[sp]->str_pok = 1;
1482         if (getsockopt(fd, lvl, optname, st[sp]->str_ptr, &st[sp]->str_cur) < 0)
1483             goto nuts;
1484         break;
1485     case O_SSOCKOPT:
1486         st[sp] = st[sp+3];
1487         if (setsockopt(fd, lvl, optname, st[sp]->str_ptr, st[sp]->str_cur) < 0)
1488             goto nuts;
1489         st[sp] = &str_yes;
1490         break;
1491     }
1492     
1493     return sp;
1494
1495 nuts:
1496     if (dowarn)
1497         warn("[gs]etsockopt() on closed fd");
1498     st[sp] = &str_undef;
1499     return sp;
1500
1501 }
1502
1503 int
1504 do_getsockname(optype, stab, arglast)
1505 int optype;
1506 STAB *stab;
1507 int *arglast;
1508 {
1509     register STR **st = stack->ary_array;
1510     register int sp = arglast[1];
1511     register STIO *stio;
1512     int fd;
1513
1514     if (!stab)
1515         goto nuts;
1516
1517     stio = stab_io(stab);
1518     if (!stio || !stio->ifp)
1519         goto nuts;
1520
1521     st[sp] = str_2mortal(str_new(257));
1522     st[sp]->str_cur = 256;
1523     st[sp]->str_pok = 1;
1524     fd = fileno(stio->ifp);
1525     switch (optype) {
1526     case O_GETSOCKNAME:
1527         if (getsockname(fd, st[sp]->str_ptr, &st[sp]->str_cur) < 0)
1528             goto nuts2;
1529         break;
1530     case O_GETPEERNAME:
1531         if (getpeername(fd, st[sp]->str_ptr, &st[sp]->str_cur) < 0)
1532             goto nuts2;
1533         break;
1534     }
1535     
1536     return sp;
1537
1538 nuts:
1539     if (dowarn)
1540         warn("get{sock,peer}name() on closed fd");
1541 nuts2:
1542     st[sp] = &str_undef;
1543     return sp;
1544
1545 }
1546
1547 int
1548 do_ghent(which,gimme,arglast)
1549 int which;
1550 int gimme;
1551 int *arglast;
1552 {
1553     register ARRAY *ary = stack;
1554     register int sp = arglast[0];
1555     register char **elem;
1556     register STR *str;
1557     struct hostent *gethostbyname();
1558     struct hostent *gethostbyaddr();
1559 #ifdef HAS_GETHOSTENT
1560     struct hostent *gethostent();
1561 #endif
1562     struct hostent *hent;
1563     unsigned long len;
1564
1565     if (gimme != G_ARRAY) {
1566         astore(ary, ++sp, str_mortal(&str_undef));
1567         return sp;
1568     }
1569
1570     if (which == O_GHBYNAME) {
1571         char *name = str_get(ary->ary_array[sp+1]);
1572
1573         hent = gethostbyname(name);
1574     }
1575     else if (which == O_GHBYADDR) {
1576         STR *addrstr = ary->ary_array[sp+1];
1577         int addrtype = (int)str_gnum(ary->ary_array[sp+2]);
1578         char *addr = str_get(addrstr);
1579
1580         hent = gethostbyaddr(addr,addrstr->str_cur,addrtype);
1581     }
1582     else
1583 #ifdef HAS_GETHOSTENT
1584         hent = gethostent();
1585 #else
1586         fatal("gethostent not implemented");
1587 #endif
1588     if (hent) {
1589 #ifndef lint
1590         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1591         str_set(str, hent->h_name);
1592         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1593         for (elem = hent->h_aliases; *elem; elem++) {
1594             str_cat(str, *elem);
1595             if (elem[1])
1596                 str_ncat(str," ",1);
1597         }
1598         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1599         str_numset(str, (double)hent->h_addrtype);
1600         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1601         len = hent->h_length;
1602         str_numset(str, (double)len);
1603 #ifdef h_addr
1604         for (elem = hent->h_addr_list; *elem; elem++) {
1605             (void)astore(ary, ++sp, str = str_mortal(&str_no));
1606             str_nset(str, *elem, len);
1607         }
1608 #else
1609         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1610         str_nset(str, hent->h_addr, len);
1611 #endif /* h_addr */
1612 #else /* lint */
1613         elem = Nullch;
1614         elem = elem;
1615         (void)astore(ary, ++sp, str_mortal(&str_no));
1616 #endif /* lint */
1617     }
1618
1619     return sp;
1620 }
1621
1622 int
1623 do_gnent(which,gimme,arglast)
1624 int which;
1625 int gimme;
1626 int *arglast;
1627 {
1628     register ARRAY *ary = stack;
1629     register int sp = arglast[0];
1630     register char **elem;
1631     register STR *str;
1632     struct netent *getnetbyname();
1633     struct netent *getnetbyaddr();
1634     struct netent *getnetent();
1635     struct netent *nent;
1636
1637     if (gimme != G_ARRAY) {
1638         astore(ary, ++sp, str_mortal(&str_undef));
1639         return sp;
1640     }
1641
1642     if (which == O_GNBYNAME) {
1643         char *name = str_get(ary->ary_array[sp+1]);
1644
1645         nent = getnetbyname(name);
1646     }
1647     else if (which == O_GNBYADDR) {
1648         unsigned long addr = U_L(str_gnum(ary->ary_array[sp+1]));
1649         int addrtype = (int)str_gnum(ary->ary_array[sp+2]);
1650
1651         nent = getnetbyaddr((long)addr,addrtype);
1652     }
1653     else
1654         nent = getnetent();
1655
1656     if (nent) {
1657 #ifndef lint
1658         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1659         str_set(str, nent->n_name);
1660         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1661         for (elem = nent->n_aliases; *elem; elem++) {
1662             str_cat(str, *elem);
1663             if (elem[1])
1664                 str_ncat(str," ",1);
1665         }
1666         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1667         str_numset(str, (double)nent->n_addrtype);
1668         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1669         str_numset(str, (double)nent->n_net);
1670 #else /* lint */
1671         elem = Nullch;
1672         elem = elem;
1673         (void)astore(ary, ++sp, str_mortal(&str_no));
1674 #endif /* lint */
1675     }
1676
1677     return sp;
1678 }
1679
1680 int
1681 do_gpent(which,gimme,arglast)
1682 int which;
1683 int gimme;
1684 int *arglast;
1685 {
1686     register ARRAY *ary = stack;
1687     register int sp = arglast[0];
1688     register char **elem;
1689     register STR *str;
1690     struct protoent *getprotobyname();
1691     struct protoent *getprotobynumber();
1692     struct protoent *getprotoent();
1693     struct protoent *pent;
1694
1695     if (gimme != G_ARRAY) {
1696         astore(ary, ++sp, str_mortal(&str_undef));
1697         return sp;
1698     }
1699
1700     if (which == O_GPBYNAME) {
1701         char *name = str_get(ary->ary_array[sp+1]);
1702
1703         pent = getprotobyname(name);
1704     }
1705     else if (which == O_GPBYNUMBER) {
1706         int proto = (int)str_gnum(ary->ary_array[sp+1]);
1707
1708         pent = getprotobynumber(proto);
1709     }
1710     else
1711         pent = getprotoent();
1712
1713     if (pent) {
1714 #ifndef lint
1715         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1716         str_set(str, pent->p_name);
1717         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1718         for (elem = pent->p_aliases; *elem; elem++) {
1719             str_cat(str, *elem);
1720             if (elem[1])
1721                 str_ncat(str," ",1);
1722         }
1723         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1724         str_numset(str, (double)pent->p_proto);
1725 #else /* lint */
1726         elem = Nullch;
1727         elem = elem;
1728         (void)astore(ary, ++sp, str_mortal(&str_no));
1729 #endif /* lint */
1730     }
1731
1732     return sp;
1733 }
1734
1735 int
1736 do_gsent(which,gimme,arglast)
1737 int which;
1738 int gimme;
1739 int *arglast;
1740 {
1741     register ARRAY *ary = stack;
1742     register int sp = arglast[0];
1743     register char **elem;
1744     register STR *str;
1745     struct servent *getservbyname();
1746     struct servent *getservbynumber();
1747     struct servent *getservent();
1748     struct servent *sent;
1749
1750     if (gimme != G_ARRAY) {
1751         astore(ary, ++sp, str_mortal(&str_undef));
1752         return sp;
1753     }
1754
1755     if (which == O_GSBYNAME) {
1756         char *name = str_get(ary->ary_array[sp+1]);
1757         char *proto = str_get(ary->ary_array[sp+2]);
1758
1759         if (proto && !*proto)
1760             proto = Nullch;
1761
1762         sent = getservbyname(name,proto);
1763     }
1764     else if (which == O_GSBYPORT) {
1765         int port = (int)str_gnum(ary->ary_array[sp+1]);
1766         char *proto = str_get(ary->ary_array[sp+2]);
1767
1768         sent = getservbyport(port,proto);
1769     }
1770     else
1771         sent = getservent();
1772     if (sent) {
1773 #ifndef lint
1774         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1775         str_set(str, sent->s_name);
1776         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1777         for (elem = sent->s_aliases; *elem; elem++) {
1778             str_cat(str, *elem);
1779             if (elem[1])
1780                 str_ncat(str," ",1);
1781         }
1782         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1783 #ifdef HAS_NTOHS
1784         str_numset(str, (double)ntohs(sent->s_port));
1785 #else
1786         str_numset(str, (double)(sent->s_port));
1787 #endif
1788         (void)astore(ary, ++sp, str = str_mortal(&str_no));
1789         str_set(str, sent->s_proto);
1790 #else /* lint */
1791         elem = Nullch;
1792         elem = elem;
1793         (void)astore(ary, ++sp, str_mortal(&str_no));
1794 #endif /* lint */
1795     }
1796
1797     return sp;
1798 }
1799
1800 #endif /* HAS_SOCKET */
1801
1802 #ifdef HAS_SELECT
1803 int
1804 do_select(gimme,arglast)
1805 int gimme;
1806 int *arglast;
1807 {
1808     register STR **st = stack->ary_array;
1809     register int sp = arglast[0];
1810     register int i;
1811     register int j;
1812     register char *s;
1813     register STR *str;
1814     double value;
1815     int maxlen = 0;
1816     int nfound;
1817     struct timeval timebuf;
1818     struct timeval *tbuf = &timebuf;
1819     int growsize;
1820 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1821     int masksize;
1822     int offset;
1823     char *fd_sets[4];
1824     int k;
1825
1826 #if BYTEORDER & 0xf0000
1827 #define ORDERBYTE (0x88888888 - BYTEORDER)
1828 #else
1829 #define ORDERBYTE (0x4444 - BYTEORDER)
1830 #endif
1831
1832 #endif
1833
1834     for (i = 1; i <= 3; i++) {
1835         j = st[sp+i]->str_cur;
1836         if (maxlen < j)
1837             maxlen = j;
1838     }
1839
1840 #if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678
1841     growsize = maxlen;          /* little endians can use vecs directly */
1842 #else
1843 #ifdef NFDBITS
1844
1845 #ifndef NBBY
1846 #define NBBY 8
1847 #endif
1848
1849     masksize = NFDBITS / NBBY;
1850 #else
1851     masksize = sizeof(long);    /* documented int, everyone seems to use long */
1852 #endif
1853     growsize = maxlen + (masksize - (maxlen % masksize));
1854     Zero(&fd_sets[0], 4, char*);
1855 #endif
1856
1857     for (i = 1; i <= 3; i++) {
1858         str = st[sp+i];
1859         j = str->str_len;
1860         if (j < growsize) {
1861             if (str->str_pok) {
1862                 Str_Grow(str,growsize);
1863                 s = str_get(str) + j;
1864                 while (++j <= growsize) {
1865                     *s++ = '\0';
1866                 }
1867             }
1868             else if (str->str_ptr) {
1869                 Safefree(str->str_ptr);
1870                 str->str_ptr = Nullch;
1871             }
1872         }
1873 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1874         s = str->str_ptr;
1875         if (s) {
1876             New(403, fd_sets[i], growsize, char);
1877             for (offset = 0; offset < growsize; offset += masksize) {
1878                 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1879                     fd_sets[i][j+offset] = s[(k % masksize) + offset];
1880             }
1881         }
1882 #endif
1883     }
1884     str = st[sp+4];
1885     if (str->str_nok || str->str_pok) {
1886         value = str_gnum(str);
1887         if (value < 0.0)
1888             value = 0.0;
1889         timebuf.tv_sec = (long)value;
1890         value -= (double)timebuf.tv_sec;
1891         timebuf.tv_usec = (long)(value * 1000000.0);
1892     }
1893     else
1894         tbuf = Null(struct timeval*);
1895
1896 #if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678
1897     nfound = select(
1898         maxlen * 8,
1899         st[sp+1]->str_ptr,
1900         st[sp+2]->str_ptr,
1901         st[sp+3]->str_ptr,
1902         tbuf);
1903 #else
1904     nfound = select(
1905         maxlen * 8,
1906         fd_sets[1],
1907         fd_sets[2],
1908         fd_sets[3],
1909         tbuf);
1910     for (i = 1; i <= 3; i++) {
1911         if (fd_sets[i]) {
1912             str = st[sp+i];
1913             s = str->str_ptr;
1914             for (offset = 0; offset < growsize; offset += masksize) {
1915                 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1916                     s[(k % masksize) + offset] = fd_sets[i][j+offset];
1917             }
1918         }
1919     }
1920 #endif
1921
1922     st[++sp] = str_mortal(&str_no);
1923     str_numset(st[sp], (double)nfound);
1924     if (gimme == G_ARRAY && tbuf) {
1925         value = (double)(timebuf.tv_sec) +
1926                 (double)(timebuf.tv_usec) / 1000000.0;
1927         st[++sp] = str_mortal(&str_no);
1928         str_numset(st[sp], value);
1929     }
1930     return sp;
1931 }
1932 #endif /* SELECT */
1933
1934 #ifdef HAS_SOCKET
1935 int
1936 do_spair(stab1, stab2, arglast)
1937 STAB *stab1;
1938 STAB *stab2;
1939 int *arglast;
1940 {
1941     register STR **st = stack->ary_array;
1942     register int sp = arglast[2];
1943     register STIO *stio1;
1944     register STIO *stio2;
1945     int domain, type, protocol, fd[2];
1946
1947     if (!stab1 || !stab2)
1948         return FALSE;
1949
1950     stio1 = stab_io(stab1);
1951     stio2 = stab_io(stab2);
1952     if (!stio1)
1953         stio1 = stab_io(stab1) = stio_new();
1954     else if (stio1->ifp)
1955         do_close(stab1,FALSE);
1956     if (!stio2)
1957         stio2 = stab_io(stab2) = stio_new();
1958     else if (stio2->ifp)
1959         do_close(stab2,FALSE);
1960
1961     domain = (int)str_gnum(st[++sp]);
1962     type = (int)str_gnum(st[++sp]);
1963     protocol = (int)str_gnum(st[++sp]);
1964 #ifdef TAINT
1965     taintproper("Insecure dependency in socketpair");
1966 #endif
1967 #ifdef HAS_SOCKETPAIR
1968     if (socketpair(domain,type,protocol,fd) < 0)
1969         return FALSE;
1970 #else
1971     fatal("Socketpair unimplemented");
1972 #endif
1973     stio1->ifp = fdopen(fd[0], "r");
1974     stio1->ofp = fdopen(fd[0], "w");
1975     stio1->type = 's';
1976     stio2->ifp = fdopen(fd[1], "r");
1977     stio2->ofp = fdopen(fd[1], "w");
1978     stio2->type = 's';
1979     if (!stio1->ifp || !stio1->ofp || !stio2->ifp || !stio2->ofp) {
1980         if (stio1->ifp) fclose(stio1->ifp);
1981         if (stio1->ofp) fclose(stio1->ofp);
1982         if (!stio1->ifp && !stio1->ofp) close(fd[0]);
1983         if (stio2->ifp) fclose(stio2->ifp);
1984         if (stio2->ofp) fclose(stio2->ofp);
1985         if (!stio2->ifp && !stio2->ofp) close(fd[1]);
1986         return FALSE;
1987     }
1988
1989     return TRUE;
1990 }
1991
1992 #endif /* HAS_SOCKET */
1993
1994 int
1995 do_gpwent(which,gimme,arglast)
1996 int which;
1997 int gimme;
1998 int *arglast;
1999 {
2000 #ifdef I_PWD
2001     register ARRAY *ary = stack;
2002     register int sp = arglast[0];
2003     register STR *str;
2004     struct passwd *getpwnam();
2005     struct passwd *getpwuid();
2006     struct passwd *getpwent();
2007     struct passwd *pwent;
2008
2009     if (gimme != G_ARRAY) {
2010         astore(ary, ++sp, str_mortal(&str_undef));
2011         return sp;
2012     }
2013
2014     if (which == O_GPWNAM) {
2015         char *name = str_get(ary->ary_array[sp+1]);
2016
2017         pwent = getpwnam(name);
2018     }
2019     else if (which == O_GPWUID) {
2020         int uid = (int)str_gnum(ary->ary_array[sp+1]);
2021
2022         pwent = getpwuid(uid);
2023     }
2024     else
2025         pwent = getpwent();
2026
2027     if (pwent) {
2028         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2029         str_set(str, pwent->pw_name);
2030         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2031         str_set(str, pwent->pw_passwd);
2032         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2033         str_numset(str, (double)pwent->pw_uid);
2034         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2035         str_numset(str, (double)pwent->pw_gid);
2036         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2037 #ifdef PWCHANGE
2038         str_numset(str, (double)pwent->pw_change);
2039 #else
2040 #ifdef PWQUOTA
2041         str_numset(str, (double)pwent->pw_quota);
2042 #else
2043 #ifdef PWAGE
2044         str_set(str, pwent->pw_age);
2045 #endif
2046 #endif
2047 #endif
2048         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2049 #ifdef PWCLASS
2050         str_set(str,pwent->pw_class);
2051 #else
2052 #ifdef PWCOMMENT
2053         str_set(str, pwent->pw_comment);
2054 #endif
2055 #endif
2056         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2057         str_set(str, pwent->pw_gecos);
2058         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2059         str_set(str, pwent->pw_dir);
2060         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2061         str_set(str, pwent->pw_shell);
2062 #ifdef PWEXPIRE
2063         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2064         str_numset(str, (double)pwent->pw_expire);
2065 #endif
2066     }
2067
2068     return sp;
2069 #else
2070     fatal("password routines not implemented");
2071 #endif
2072 }
2073
2074 int
2075 do_ggrent(which,gimme,arglast)
2076 int which;
2077 int gimme;
2078 int *arglast;
2079 {
2080 #ifdef I_GRP
2081     register ARRAY *ary = stack;
2082     register int sp = arglast[0];
2083     register char **elem;
2084     register STR *str;
2085     struct group *getgrnam();
2086     struct group *getgrgid();
2087     struct group *getgrent();
2088     struct group *grent;
2089
2090     if (gimme != G_ARRAY) {
2091         astore(ary, ++sp, str_mortal(&str_undef));
2092         return sp;
2093     }
2094
2095     if (which == O_GGRNAM) {
2096         char *name = str_get(ary->ary_array[sp+1]);
2097
2098         grent = getgrnam(name);
2099     }
2100     else if (which == O_GGRGID) {
2101         int gid = (int)str_gnum(ary->ary_array[sp+1]);
2102
2103         grent = getgrgid(gid);
2104     }
2105     else
2106         grent = getgrent();
2107
2108     if (grent) {
2109         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2110         str_set(str, grent->gr_name);
2111         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2112         str_set(str, grent->gr_passwd);
2113         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2114         str_numset(str, (double)grent->gr_gid);
2115         (void)astore(ary, ++sp, str = str_mortal(&str_no));
2116         for (elem = grent->gr_mem; *elem; elem++) {
2117             str_cat(str, *elem);
2118             if (elem[1])
2119                 str_ncat(str," ",1);
2120         }
2121     }
2122
2123     return sp;
2124 #else
2125     fatal("group routines not implemented");
2126 #endif
2127 }
2128
2129 int
2130 do_dirop(optype,stab,gimme,arglast)
2131 int optype;
2132 STAB *stab;
2133 int gimme;
2134 int *arglast;
2135 {
2136 #if defined(DIRENT) && defined(HAS_READDIR)
2137     register ARRAY *ary = stack;
2138     register STR **st = ary->ary_array;
2139     register int sp = arglast[1];
2140     register STIO *stio;
2141     long along;
2142 #ifndef telldir
2143     long telldir();
2144 #endif
2145     struct DIRENT *readdir();
2146     register struct DIRENT *dp;
2147
2148     if (!stab)
2149         goto nope;
2150     if (!(stio = stab_io(stab)))
2151         stio = stab_io(stab) = stio_new();
2152     if (!stio->dirp && optype != O_OPENDIR)
2153         goto nope;
2154     st[sp] = &str_yes;
2155     switch (optype) {
2156     case O_OPENDIR:
2157         if (stio->dirp)
2158             closedir(stio->dirp);
2159         if (!(stio->dirp = opendir(str_get(st[sp+1]))))
2160             goto nope;
2161         break;
2162     case O_READDIR:
2163         if (gimme == G_ARRAY) {
2164             --sp;
2165             while (dp = readdir(stio->dirp)) {
2166 #ifdef DIRNAMLEN
2167                 (void)astore(ary,++sp,
2168                   str_2mortal(str_make(dp->d_name,dp->d_namlen)));
2169 #else
2170                 (void)astore(ary,++sp,
2171                   str_2mortal(str_make(dp->d_name,0)));
2172 #endif
2173             }
2174         }
2175         else {
2176             if (!(dp = readdir(stio->dirp)))
2177                 goto nope;
2178             st[sp] = str_mortal(&str_undef);
2179 #ifdef DIRNAMLEN
2180             str_nset(st[sp], dp->d_name, dp->d_namlen);
2181 #else
2182             str_set(st[sp], dp->d_name);
2183 #endif
2184         }
2185         break;
2186 #if MACH
2187     case O_TELLDIR:
2188     case O_SEEKDIR:
2189         goto nope;
2190 #else
2191     case O_TELLDIR:
2192         st[sp] = str_mortal(&str_undef);
2193         str_numset(st[sp], (double)telldir(stio->dirp));
2194         break;
2195     case O_SEEKDIR:
2196         st[sp] = str_mortal(&str_undef);
2197         along = (long)str_gnum(st[sp+1]);
2198         (void)seekdir(stio->dirp,along);
2199         break;
2200 #endif
2201     case O_REWINDDIR:
2202         st[sp] = str_mortal(&str_undef);
2203         (void)rewinddir(stio->dirp);
2204         break;
2205     case O_CLOSEDIR:
2206         st[sp] = str_mortal(&str_undef);
2207         (void)closedir(stio->dirp);
2208         stio->dirp = 0;
2209         break;
2210     }
2211     return sp;
2212
2213 nope:
2214     st[sp] = &str_undef;
2215     return sp;
2216
2217 #else
2218     fatal("Unimplemented directory operation");
2219 #endif
2220 }
2221
2222 apply(type,arglast)
2223 int type;
2224 int *arglast;
2225 {
2226     register STR **st = stack->ary_array;
2227     register int sp = arglast[1];
2228     register int items = arglast[2] - sp;
2229     register int val;
2230     register int val2;
2231     register int tot = 0;
2232     char *s;
2233
2234 #ifdef TAINT
2235     for (st += ++sp; items--; st++)
2236         tainted |= (*st)->str_tainted;
2237     st = stack->ary_array;
2238     sp = arglast[1];
2239     items = arglast[2] - sp;
2240 #endif
2241     switch (type) {
2242     case O_CHMOD:
2243 #ifdef TAINT
2244         taintproper("Insecure dependency in chmod");
2245 #endif
2246         if (--items > 0) {
2247             tot = items;
2248             val = (int)str_gnum(st[++sp]);
2249             while (items--) {
2250                 if (chmod(str_get(st[++sp]),val))
2251                     tot--;
2252             }
2253         }
2254         break;
2255 #ifdef HAS_CHOWN
2256     case O_CHOWN:
2257 #ifdef TAINT
2258         taintproper("Insecure dependency in chown");
2259 #endif
2260         if (items > 2) {
2261             items -= 2;
2262             tot = items;
2263             val = (int)str_gnum(st[++sp]);
2264             val2 = (int)str_gnum(st[++sp]);
2265             while (items--) {
2266                 if (chown(str_get(st[++sp]),val,val2))
2267                     tot--;
2268             }
2269         }
2270         break;
2271 #endif
2272 #ifdef HAS_KILL
2273     case O_KILL:
2274 #ifdef TAINT
2275         taintproper("Insecure dependency in kill");
2276 #endif
2277         if (--items > 0) {
2278             tot = items;
2279             s = str_get(st[++sp]);
2280             if (isupper(*s)) {
2281                 if (*s == 'S' && s[1] == 'I' && s[2] == 'G')
2282                     s += 3;
2283                 if (!(val = whichsig(s)))
2284                     fatal("Unrecognized signal name \"%s\"",s);
2285             }
2286             else
2287                 val = (int)str_gnum(st[sp]);
2288             if (val < 0) {
2289                 val = -val;
2290                 while (items--) {
2291                     int proc = (int)str_gnum(st[++sp]);
2292 #ifdef HAS_KILLPG
2293                     if (killpg(proc,val))       /* BSD */
2294 #else
2295                     if (kill(-proc,val))        /* SYSV */
2296 #endif
2297                         tot--;
2298                 }
2299             }
2300             else {
2301                 while (items--) {
2302                     if (kill((int)(str_gnum(st[++sp])),val))
2303                         tot--;
2304                 }
2305             }
2306         }
2307         break;
2308 #endif
2309     case O_UNLINK:
2310 #ifdef TAINT
2311         taintproper("Insecure dependency in unlink");
2312 #endif
2313         tot = items;
2314         while (items--) {
2315             s = str_get(st[++sp]);
2316             if (euid || unsafe) {
2317                 if (UNLINK(s))
2318                     tot--;
2319             }
2320             else {      /* don't let root wipe out directories without -U */
2321 #ifdef HAS_LSTAT
2322                 if (lstat(s,&statbuf) < 0 || S_ISDIR(statbuf.st_mode))
2323 #else
2324                 if (stat(s,&statbuf) < 0 || S_ISDIR(statbuf.st_mode))
2325 #endif
2326                     tot--;
2327                 else {
2328                     if (UNLINK(s))
2329                         tot--;
2330                 }
2331             }
2332         }
2333         break;
2334     case O_UTIME:
2335 #ifdef TAINT
2336         taintproper("Insecure dependency in utime");
2337 #endif
2338         if (items > 2) {
2339 #ifdef I_UTIME
2340             struct utimbuf utbuf;
2341 #else
2342             struct {
2343                 long    actime;
2344                 long    modtime;
2345             } utbuf;
2346 #endif
2347
2348             Zero(&utbuf, sizeof utbuf, char);
2349             utbuf.actime = (long)str_gnum(st[++sp]);    /* time accessed */
2350             utbuf.modtime = (long)str_gnum(st[++sp]);    /* time modified */
2351             items -= 2;
2352 #ifndef lint
2353             tot = items;
2354             while (items--) {
2355                 if (utime(str_get(st[++sp]),&utbuf))
2356                     tot--;
2357             }
2358 #endif
2359         }
2360         else
2361             items = 0;
2362         break;
2363     }
2364     return tot;
2365 }
2366
2367 /* Do the permissions allow some operation?  Assumes statcache already set. */
2368
2369 int
2370 cando(bit, effective, statbufp)
2371 int bit;
2372 int effective;
2373 register struct stat *statbufp;
2374 {
2375 #ifdef MSDOS
2376     /* [Comments and code from Len Reed]
2377      * MS-DOS "user" is similar to UNIX's "superuser," but can't write
2378      * to write-protected files.  The execute permission bit is set
2379      * by the Miscrosoft C library stat() function for the following:
2380      *          .exe files
2381      *          .com files
2382      *          .bat files
2383      *          directories
2384      * All files and directories are readable.
2385      * Directories and special files, e.g. "CON", cannot be
2386      * write-protected.
2387      * [Comment by Tom Dinger -- a directory can have the write-protect
2388      *          bit set in the file system, but DOS permits changes to
2389      *          the directory anyway.  In addition, all bets are off
2390      *          here for networked software, such as Novell and
2391      *          Sun's PC-NFS.]
2392      */
2393
2394      return (bit & statbufp->st_mode) ? TRUE : FALSE;
2395
2396 #else /* ! MSDOS */
2397     if ((effective ? euid : uid) == 0) {        /* root is special */
2398         if (bit == S_IXUSR) {
2399             if (statbufp->st_mode & 0111 || S_ISDIR(statbufp->st_mode))
2400                 return TRUE;
2401         }
2402         else
2403             return TRUE;                /* root reads and writes anything */
2404         return FALSE;
2405     }
2406     if (statbufp->st_uid == (effective ? euid : uid) ) {
2407         if (statbufp->st_mode & bit)
2408             return TRUE;        /* ok as "user" */
2409     }
2410     else if (ingroup((int)statbufp->st_gid,effective)) {
2411         if (statbufp->st_mode & bit >> 3)
2412             return TRUE;        /* ok as "group" */
2413     }
2414     else if (statbufp->st_mode & bit >> 6)
2415         return TRUE;    /* ok as "other" */
2416     return FALSE;
2417 #endif /* ! MSDOS */
2418 }
2419
2420 int
2421 ingroup(testgid,effective)
2422 int testgid;
2423 int effective;
2424 {
2425     if (testgid == (effective ? egid : gid))
2426         return TRUE;
2427 #ifdef HAS_GETGROUPS
2428 #ifndef NGROUPS
2429 #define NGROUPS 32
2430 #endif
2431     {
2432         GROUPSTYPE gary[NGROUPS];
2433         int anum;
2434
2435         anum = getgroups(NGROUPS,gary);
2436         while (--anum >= 0)
2437             if (gary[anum] == testgid)
2438                 return TRUE;
2439     }
2440 #endif
2441     return FALSE;
2442 }
2443
2444 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
2445
2446 int
2447 do_ipcget(optype, arglast)
2448 int optype;
2449 int *arglast;
2450 {
2451     register STR **st = stack->ary_array;
2452     register int sp = arglast[0];
2453     key_t key;
2454     int n, flags;
2455
2456     key = (key_t)str_gnum(st[++sp]);
2457     n = (optype == O_MSGGET) ? 0 : (int)str_gnum(st[++sp]);
2458     flags = (int)str_gnum(st[++sp]);
2459     errno = 0;
2460     switch (optype)
2461     {
2462 #ifdef HAS_MSG
2463     case O_MSGGET:
2464         return msgget(key, flags);
2465 #endif
2466 #ifdef HAS_SEM
2467     case O_SEMGET:
2468         return semget(key, n, flags);
2469 #endif
2470 #ifdef HAS_SHM
2471     case O_SHMGET:
2472         return shmget(key, n, flags);
2473 #endif
2474 #if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
2475     default:
2476         fatal("%s not implemented", opname[optype]);
2477 #endif
2478     }
2479     return -1;                  /* should never happen */
2480 }
2481
2482 int
2483 do_ipcctl(optype, arglast)
2484 int optype;
2485 int *arglast;
2486 {
2487     register STR **st = stack->ary_array;
2488     register int sp = arglast[0];
2489     STR *astr;
2490     char *a;
2491     int id, n, cmd, infosize, getinfo, ret;
2492
2493     id = (int)str_gnum(st[++sp]);
2494     n = (optype == O_SEMCTL) ? (int)str_gnum(st[++sp]) : 0;
2495     cmd = (int)str_gnum(st[++sp]);
2496     astr = st[++sp];
2497
2498     infosize = 0;
2499     getinfo = (cmd == IPC_STAT);
2500
2501     switch (optype)
2502     {
2503 #ifdef HAS_MSG
2504     case O_MSGCTL:
2505         if (cmd == IPC_STAT || cmd == IPC_SET)
2506             infosize = sizeof(struct msqid_ds);
2507         break;
2508 #endif
2509 #ifdef HAS_SHM
2510     case O_SHMCTL:
2511         if (cmd == IPC_STAT || cmd == IPC_SET)
2512             infosize = sizeof(struct shmid_ds);
2513         break;
2514 #endif
2515 #ifdef HAS_SEM
2516     case O_SEMCTL:
2517         if (cmd == IPC_STAT || cmd == IPC_SET)
2518             infosize = sizeof(struct semid_ds);
2519         else if (cmd == GETALL || cmd == SETALL)
2520         {
2521             struct semid_ds semds;
2522             if (semctl(id, 0, IPC_STAT, &semds) == -1)
2523                 return -1;
2524             getinfo = (cmd == GETALL);
2525 #ifdef _POSIX_SOURCE
2526             infosize = semds.sem_nsems * sizeof(ushort_t);
2527 #else
2528             infosize = semds.sem_nsems * sizeof(ushort);
2529 #endif
2530         }
2531         break;
2532 #endif
2533 #if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
2534     default:
2535         fatal("%s not implemented", opname[optype]);
2536 #endif
2537     }
2538
2539     if (infosize)
2540     {
2541         if (getinfo)
2542         {
2543             STR_GROW(astr, infosize+1);
2544             a = str_get(astr);
2545         }
2546         else
2547         {
2548             a = str_get(astr);
2549             if (astr->str_cur != infosize)
2550             {
2551                 errno = EINVAL;
2552                 return -1;
2553             }
2554         }
2555     }
2556     else
2557     {
2558         int i = (int)str_gnum(astr);
2559         a = (char *)i;          /* ouch */
2560     }
2561     errno = 0;
2562     switch (optype)
2563     {
2564 #ifdef HAS_MSG
2565     case O_MSGCTL:
2566         ret = msgctl(id, cmd, a);
2567         break;
2568 #endif
2569 #ifdef HAS_SEM
2570     case O_SEMCTL:
2571         ret = semctl(id, n, cmd, a);
2572         break;
2573 #endif
2574 #ifdef HAS_SHM
2575     case O_SHMCTL:
2576         ret = shmctl(id, cmd, a);
2577         break;
2578 #endif
2579     }
2580     if (getinfo && ret >= 0) {
2581         astr->str_cur = infosize;
2582         astr->str_ptr[infosize] = '\0';
2583     }
2584     return ret;
2585 }
2586
2587 int
2588 do_msgsnd(arglast)
2589 int *arglast;
2590 {
2591 #ifdef HAS_MSG
2592     register STR **st = stack->ary_array;
2593     register int sp = arglast[0];
2594     STR *mstr;
2595     char *mbuf;
2596     int id, msize, flags;
2597
2598     id = (int)str_gnum(st[++sp]);
2599     mstr = st[++sp];
2600     flags = (int)str_gnum(st[++sp]);
2601     mbuf = str_get(mstr);
2602     if ((msize = mstr->str_cur - sizeof(long)) < 0) {
2603         errno = EINVAL;
2604         return -1;
2605     }
2606     errno = 0;
2607     return msgsnd(id, mbuf, msize, flags);
2608 #else
2609     fatal("msgsnd not implemented");
2610 #endif
2611 }
2612
2613 int
2614 do_msgrcv(arglast)
2615 int *arglast;
2616 {
2617 #ifdef HAS_MSG
2618     register STR **st = stack->ary_array;
2619     register int sp = arglast[0];
2620     STR *mstr;
2621     char *mbuf;
2622     long mtype;
2623     int id, msize, flags, ret;
2624
2625     id = (int)str_gnum(st[++sp]);
2626     mstr = st[++sp];
2627     msize = (int)str_gnum(st[++sp]);
2628     mtype = (long)str_gnum(st[++sp]);
2629     flags = (int)str_gnum(st[++sp]);
2630     mbuf = str_get(mstr);
2631     if (mstr->str_cur < sizeof(long)+msize+1) {
2632         STR_GROW(mstr, sizeof(long)+msize+1);
2633         mbuf = str_get(mstr);
2634     }
2635     errno = 0;
2636     ret = msgrcv(id, mbuf, msize, mtype, flags);
2637     if (ret >= 0) {
2638         mstr->str_cur = sizeof(long)+ret;
2639         mstr->str_ptr[sizeof(long)+ret] = '\0';
2640     }
2641     return ret;
2642 #else
2643     fatal("msgrcv not implemented");
2644 #endif
2645 }
2646
2647 int
2648 do_semop(arglast)
2649 int *arglast;
2650 {
2651 #ifdef HAS_SEM
2652     register STR **st = stack->ary_array;
2653     register int sp = arglast[0];
2654     STR *opstr;
2655     char *opbuf;
2656     int id, opsize;
2657
2658     id = (int)str_gnum(st[++sp]);
2659     opstr = st[++sp];
2660     opbuf = str_get(opstr);
2661     opsize = opstr->str_cur;
2662     if (opsize < sizeof(struct sembuf)
2663         || (opsize % sizeof(struct sembuf)) != 0) {
2664         errno = EINVAL;
2665         return -1;
2666     }
2667     errno = 0;
2668     return semop(id, opbuf, opsize/sizeof(struct sembuf));
2669 #else
2670     fatal("semop not implemented");
2671 #endif
2672 }
2673
2674 int
2675 do_shmio(optype, arglast)
2676 int optype;
2677 int *arglast;
2678 {
2679 #ifdef HAS_SHM
2680     register STR **st = stack->ary_array;
2681     register int sp = arglast[0];
2682     STR *mstr;
2683     char *mbuf, *shm;
2684     int id, mpos, msize;
2685     struct shmid_ds shmds;
2686     extern char *shmat();
2687
2688     id = (int)str_gnum(st[++sp]);
2689     mstr = st[++sp];
2690     mpos = (int)str_gnum(st[++sp]);
2691     msize = (int)str_gnum(st[++sp]);
2692     errno = 0;
2693     if (shmctl(id, IPC_STAT, &shmds) == -1)
2694         return -1;
2695     if (mpos < 0 || msize < 0 || mpos + msize > shmds.shm_segsz) {
2696         errno = EFAULT;         /* can't do as caller requested */
2697         return -1;
2698     }
2699     shm = shmat(id, (char *)NULL, (optype == O_SHMREAD) ? SHM_RDONLY : 0);
2700     if (shm == (char *)-1)      /* I hate System V IPC, I really do */
2701         return -1;
2702     mbuf = str_get(mstr);
2703     if (optype == O_SHMREAD) {
2704         if (mstr->str_cur < msize) {
2705             STR_GROW(mstr, msize+1);
2706             mbuf = str_get(mstr);
2707         }
2708         bcopy(shm + mpos, mbuf, msize);
2709         mstr->str_cur = msize;
2710         mstr->str_ptr[msize] = '\0';
2711     }
2712     else {
2713         int n;
2714
2715         if ((n = mstr->str_cur) > msize)
2716             n = msize;
2717         bcopy(mbuf, shm + mpos, n);
2718         if (n < msize)
2719             bzero(shm + mpos + n, msize - n);
2720     }
2721     return shmdt(shm);
2722 #else
2723     fatal("shm I/O not implemented");
2724 #endif
2725 }
2726
2727 #endif /* SYSV IPC */