commands/elvis/system.c

   1 /* system.c  -- UNIX version */
   2
   3 /* Author:
   4  *      Steve Kirkendall
   5  *      14407 SW Teal Blvd. #C
   6  *      Beaverton, OR 97005
   7  *      kirkenda@cs.pdx.edu
   8  */
   9
  10
  11 /* This file contains a new version of the system() function and related stuff.
  12  *
  13  * Entry points are:
  14  *      system(cmd)             - run a single shell command
  15  *      wildcard(names)         - expand wildcard characters in filanames
  16  *      filter(m,n,cmd,back)    - run text lines through a filter program
  17  *
  18  * This is probably the single least portable file in the program.  The code
  19  * shown here should work correctly if it links at all; it will work on UNIX
  20  * and any O.S./Compiler combination which adheres to UNIX forking conventions.
  21  */
  22
  23 #include "config.h"
  24 #include "vi.h"
  25 extern char     **environ;
  26
  27 #if ANY_UNIX
  28
  29 /* This is a new version of the system() function.  The only difference
  30  * between this one and the library one is: this one uses the o_shell option.
  31  */
  32 int system(cmd)
  33         char    *cmd;   /* a command to run */
  34 {
  35         int     pid;    /* process ID of child */
  36         int     died;
  37         int     status; /* exit status of the command */
  38
  39
  40         signal(SIGINT, SIG_IGN);
  41         pid = fork();
  42         switch (pid)
  43         {
  44           case -1:                                              /* error */
  45                 msg("fork() failed");
  46                 status = -1;
  47                 break;
  48
  49           case 0:                                               /* child */
  50                 /* for the child, close all files except stdin/out/err */
  51                 for (status = 3; status < 60 && (close(status), errno != EINVAL); status++)
  52                 {
  53                 }
  54
  55                 signal(SIGINT, SIG_DFL);
  56                 if (cmd == o_shell)
  57                 {
  58                         execle(o_shell, o_shell, (char *)0, environ);
  59                 }
  60                 else
  61                 {
  62                         execle(o_shell, o_shell, "-c", cmd, (char *)0, environ);
  63                 }
  64                 msg("execle(\"%s\", ...) failed", o_shell);
  65                 exit(1); /* if we get here, the exec failed */
  66
  67           default:                                              /* parent */
  68                 do
  69                 {
  70                         died = wait(&status);
  71                 } while (died >= 0 && died != pid);
  72                 if (died < 0)
  73                 {
  74                         status = -1;
  75                 }
  76                 signal(SIGINT, (void (*)()) trapint);
  77         }
  78
  79         return status;
  80 }
  81
  82 /* This private function opens a pipe from a filter.  It is similar to the
  83  * system() function above, and to popen(cmd, "r").
  84  */
  85 int rpipe(cmd, in)
  86         char    *cmd;   /* the filter command to use */
  87         int     in;     /* the fd to use for stdin */
  88 {
  89         int     r0w1[2];/* the pipe fd's */
  90
  91         /* make the pipe */
  92         if (pipe(r0w1) < 0)
  93         {
  94                 return -1;      /* pipe failed */
  95         }
  96
  97         /* The parent process (elvis) ignores signals while the filter runs.
  98          * The child (the filter program) will reset this, so that it can
  99          * catch the signal.
 100          */
 101         signal(SIGINT, SIG_IGN);
 102
 103         switch (fork())
 104         {
 105           case -1:                                              /* error */
 106                 return -1;
 107
 108           case 0:                                               /* child */
 109                 /* close the "read" end of the pipe */
 110                 close(r0w1[0]);
 111
 112                 /* redirect stdout to go to the "write" end of the pipe */
 113                 close(1);
 114                 dup(r0w1[1]);
 115                 close(2);
 116                 dup(r0w1[1]);
 117                 close(r0w1[1]);
 118
 119                 /* redirect stdin */
 120                 if (in != 0)
 121                 {
 122                         close(0);
 123                         dup(in);
 124                         close(in);
 125                 }
 126
 127                 /* the filter should accept SIGINT signals */
 128                 signal(SIGINT, SIG_DFL);
 129
 130                 /* exec the shell to run the command */
 131                 execle(o_shell, o_shell, "-c", cmd, (char *)0, environ);
 132                 exit(1); /* if we get here, exec failed */
 133
 134           default:                                              /* parent */
 135                 /* close the "write" end of the pipe */
 136                 close(r0w1[1]);
 137
 138                 return r0w1[0];
 139         }
 140 }
 141
 142 #endif /* non-DOS */
 143
 144 #if OSK
 145
 146 /* This private function opens a pipe from a filter.  It is similar to the
 147  * system() function above, and to popen(cmd, "r").
 148  */
 149 int rpipe(cmd, in)
 150         char    *cmd;   /* the filter command to use */
 151         int     in;     /* the fd to use for stdin */
 152 {
 153         return osk_popen(cmd, "r", in, 0);
 154 }
 155 #endif
 156
 157 #if ANY_UNIX || OSK
 158
 159 /* This function closes the pipe opened by rpipe(), and returns 0 for success */
 160 int rpclose(fd)
 161         int     fd;
 162 {
 163         int     status;
 164
 165         close(fd);
 166         wait(&status);
 167         signal(SIGINT, (void (*)()) trapint);
 168         return status;
 169 }
 170
 171 #endif /* non-DOS */
 172
 173 /* This function expands wildcards in a filename or filenames.  It does this
 174  * by running the "echo" command on the filenames via the shell; it is assumed
 175  * that the shell will expand the names for you.  If for any reason it can't
 176  * run echo, then it returns the names unmodified.
 177  */
 178
 179 #if MSDOS || TOS
 180 #define PROG    "wildcard "
 181 #define PROGLEN 9
 182 #include <string.h>
 183 #else
 184 #define PROG    "echo "
 185 #define PROGLEN 5
 186 #endif
 187
 188 #if !AMIGA
 189 char *wildcard(names)
 190         char    *names;
 191 {
 192
 193 # if VMS
 194 /*
 195    We could use expand() [vmswild.c], but what's the point on VMS?
 196    Anyway, echo is the wrong thing to do, it takes too long to build
 197    a subprocess on VMS and any "echo" program would have to be supplied
 198    by elvis.  More importantly, many VMS utilities expand names
 199    themselves (the shell doesn't do any expansion) so the concept is
 200    non-native.  jdc
 201 */
 202         return names;
 203 # else
 204
 205         int     i, j, fd;
 206         REG char *s, *d;
 207
 208
 209         /* build the echo command */
 210         if (names != tmpblk.c)
 211         {
 212                 /* the names aren't in tmpblk.c, so we can do it the easy way */
 213                 strcpy(tmpblk.c, PROG);
 214                 strcat(tmpblk.c, names);
 215         }
 216         else
 217         {
 218                 /* the names are already in tmpblk.c, so shift them to make
 219                  * room for the word "echo "
 220                  */
 221                 for (s = names + strlen(names) + 1, d = s + PROGLEN; s > names; )
 222                 {
 223                         *--d = *--s;
 224                 }
 225                 strncpy(names, PROG, PROGLEN);
 226         }
 227
 228         /* run the command & read the resulting names */
 229         fd = rpipe(tmpblk.c, 0);
 230         if (fd < 0) return names;
 231         i = 0;
 232         do
 233         {
 234                 j = tread(fd, tmpblk.c + i, BLKSIZE - i);
 235                 i += j;
 236         } while (j > 0);
 237
 238         /* successful? */
 239         if (rpclose(fd) == 0 && j == 0 && i < BLKSIZE && i > 0)
 240         {
 241                 tmpblk.c[i-1] = '\0'; /* "i-1" so we clip off the newline */
 242                 return tmpblk.c;
 243         }
 244         else
 245         {
 246                 return names;
 247         }
 248 # endif
 249 }
 250 #endif
 251
 252 /* This function runs a range of lines through a filter program, and replaces
 253  * the original text with the filtered version.  As a special case, if "to"
 254  * is MARK_UNSET, then it runs the filter program with stdin coming from
 255  * /dev/null, and inserts any output lines.
 256  */
 257 int filter(from, to, cmd, back)
 258         MARK    from, to;       /* the range of lines to filter */
 259         char    *cmd;           /* the filter command */
 260         int     back;           /* boolean: will we read lines back? */
 261 {
 262         int     scratch;        /* fd of the scratch file */
 263         int     fd;             /* fd of the pipe from the filter */
 264         char    scrout[50];     /* name of the scratch out file */
 265         MARK    new;            /* place where new text should go */
 266         long    sent, rcvd;     /* number of lines sent/received */
 267         int     i, j;
 268
 269         /* write the lines (if specified) to a temp file */
 270         if (to)
 271         {
 272                 /* we have lines */
 273 #if MSDOS || TOS
 274                 strcpy(scrout, o_directory);
 275                 if ((i=strlen(scrout)) && !strchr("\\/:", scrout[i-1]))
 276                         scrout[i++]=SLASH;
 277                 strcpy(scrout+i, SCRATCHOUT+3);
 278 #else
 279                 sprintf(scrout, SCRATCHOUT, o_directory);
 280 #endif
 281                 mktemp(scrout);
 282                 cmd_write(from, to, CMD_BANG, FALSE, scrout);
 283                 sent = markline(to) - markline(from) + 1L;
 284
 285                 /* use those lines as stdin */
 286                 scratch = open(scrout, O_RDONLY);
 287                 if (scratch < 0)
 288                 {
 289                         unlink(scrout);
 290                         return -1;
 291                 }
 292         }
 293         else
 294         {
 295                 scratch = 0;
 296                 sent = 0L;
 297         }
 298
 299         /* start the filter program */
 300 #if VMS
 301         /*
 302            VMS doesn't know a thing about file descriptor 0.  The rpipe
 303            concept is non-portable.  Hence we need a file name argument.
 304         */
 305         fd = rpipe(cmd, scratch, scrout);
 306 #else
 307         fd = rpipe(cmd, scratch);
 308 #endif
 309         if (fd < 0)
 310         {
 311                 if (to)
 312                 {
 313                         close(scratch);
 314                         unlink(scrout);
 315                 }
 316                 return -1;
 317         }
 318
 319         if (back)
 320         {
 321                 ChangeText
 322                 {
 323                         /* adjust MARKs for whole lines, and set "new" */
 324                         from &= ~(BLKSIZE - 1);
 325                         if (to)
 326                         {
 327                                 to &= ~(BLKSIZE - 1);
 328                                 to += BLKSIZE;
 329                                 new = to;
 330                         }
 331                         else
 332                         {
 333                                 new = from + BLKSIZE;
 334                         }
 335
 336 #if VMS
 337 /* Reading from a VMS mailbox (pipe) is record oriented... */
 338 # define tread vms_pread
 339 #endif
 340
 341                         /* repeatedly read in new text and add it */
 342                         rcvd = 0L;
 343                         while ((i = tread(fd, tmpblk.c, BLKSIZE - 1)) > 0)
 344                         {
 345                                 tmpblk.c[i] = '\0';
 346                                 add(new, tmpblk.c);
 347 #if VMS
 348                                 /* What!  An advantage to record oriented reads? */
 349                                 new += (i - 1);
 350                                 new = (new & ~(BLKSIZE - 1)) + BLKSIZE;
 351                                 rcvd++;
 352 #else
 353                                 for (i = 0; tmpblk.c[i]; i++)
 354                                 {
 355                                         if (tmpblk.c[i] == '\n')
 356                                         {
 357                                                 new = (new & ~(BLKSIZE - 1)) + BLKSIZE;
 358                                                 rcvd++;
 359                                         }
 360                                         else
 361                                         {
 362                                                 new++;
 363                                         }
 364                                 }
 365 #endif
 366                         }
 367                 }
 368
 369                 /* delete old text, if any */
 370                 if (to)
 371                 {
 372                         cut(from, to);
 373                         delete(from, to);
 374                 }
 375         }
 376         else
 377         {
 378                 /* read the command's output, and copy it to the screen */
 379                 while ((i = tread(fd, tmpblk.c, BLKSIZE - 1)) > 0)
 380                 {
 381                         for (j = 0; j < i; j++)
 382                         {
 383                                 addch(tmpblk.c[j]);
 384                         }
 385                 }
 386                 rcvd = 0;
 387         }
 388
 389         /* Reporting... */
 390         if (sent >= *o_report || rcvd >= *o_report)
 391         {
 392                 if (sent > 0L && rcvd > 0L)
 393                 {
 394                         msg("%ld lines out, %ld lines back", sent, rcvd);
 395                 }
 396                 else if (sent > 0)
 397                 {
 398                         msg("%ld lines written to filter", sent);
 399                 }
 400                 else
 401                 {
 402                         msg("%ld lines read from filter", rcvd);
 403                 }
 404         }
 405         rptlines = 0L;
 406
 407         /* cleanup */
 408         rpclose(fd);
 409         if (to)
 410         {
 411                 close(scratch);
 412                 unlink(scrout);
 413         }
 414         return 0;
 415 }