Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/misc/volume39/planner/part01/plan.c

C/C++ Source or Header | 1993-08-23 | 4.9 KB | 209 lines

/*    THIS IS THE UNPUBLISHED SOURCE CODE OF REMBO        */
/*    The copyright notice above does not evidence any       */
/*    actual or intended publication of such source code.    */
/*    So, use it if you like, but give me credit.        */


/*     Usage: plan [-f file_name] program_name            */


/*    Description:                    */

/*     This program takes the full pathname of an    */
/*     executable and runs it on a fifo in the     */
/*    user's home directory named .plan.  This    */
/*     way, when finger is executed, the output    */
/*     of the program goes to the fifo.        */

/*    Written by:  Tony Rems                 */

/*     Send bugs and flames to /dev/null or         */
/*     [e-mail]                 */

/*    Modifications:                    */

/*    September 1991                    */
/*           (by Geoff Loker [e-mail])    */
/*    Modified the program so that the path to the    */
/*    .plan file is not hardcoded in.  Now any number    */
/*    of users can use the program at the same time.    */
/*    I also modified the program to use an optional    */
/*    argument to specify which file to use.  The    */
/*    default file used is still the user's .plan,    */
/*    but this can now also be used to set up        */
/*    .signatures or any other file the user wants.    */

/*    Even more modifications                */

/*    January 1992                    */
/*          (by Karen Bruner [e-mail]) */
/*    Added pid_deal function, so people can stick    */
/*     the program in their .login, and then have it    */
/*    killed by their .logout.  Program will not    */
/*    run if a .planpid file, the file with the PID    */
/*    for plan, already exists in the user's home    */
/*    directory.                    */

#include <sys/types.h>
#include <sys/file.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <signal.h>
#include <string.h>

/* Defines */
#define PERMS 0666
#define USAGE "%s [-f file_name] program_name\n"

/* Function prototypes */
void sig_handler();
int pid_deal();

main (argc, argv)
int argc;
char *argv[];
{
        int c, fflg;
    char *file;
        extern char *optarg;
    extern int optind;
    int fd;
    int pid;
    int status;
    char *getenv(), *home, plan[256], *strcat(), *strcpy();
    int pid_check;

    fflg = c = 0;
    while ((c = getopt(argc, argv, "f:")) != EOF) {
      file = optarg;
      fflg++;
    }

/* Comment out the next line if you don't want to have PID recorded
   to file .planpid */

    pid_check = pid_deal(); /* check for .planpid, if none, write
                   .planpid */

/* Uncomment next line if you commented out previous line */

/*  pid_check = 1; */

  if (pid_check == 1)  /* execute remaining part of program if .planpid
              does not exist, i.e., no other plan process is
              running */
    {
    if (fflg)
      strcpy(plan, file);
    else {
      home = getenv("HOME");
      strcpy(plan, home);
      strcat(plan, "/.plan");
    }
/*    setenv("PLAN", plan, 1); */

    if ( argc != optind + 1 ) {
        fprintf (stderr, USAGE, argv[0]);
        exit(1);
    }  /* if */

/* Catch interrupts for cleanup */
    signal(SIGTERM, sig_handler);
    signal(SIGINT, sig_handler);
    signal(SIGHUP, sig_handler);

    unlink (plan);

/* Make the fifo */
    if ((mknod(plan, S_IFIFO | PERMS, 0)) < 0 ) {
        perror("mknod");
        exit(2);
    }  /* if */

    while (1) {
        if ((fd = open(plan, O_WRONLY)) < 0 ) {
            perror("open");
            exit(3);
        } /* if */

/* Once our open completes we know that someone else has
 * opened the FIFO for reading, so we can know run our
 * program on it.  So, we fork, exec our program and
 * wait for the child to complete.
 */
        switch (pid = fork()) {
            case -1:
                perror("fork");
                exit(4);
                break;
            case 0:
/* If we're in the child, we copy our fifo to stdout */
/* and exec the program given */
                dup2(fd, 1);
                execlp(argv[optind],argv[optind],(void *)NULL);
                perror("child returned");
                exit(5);
                break;
            default:
/* If we're in the parent, we close the pipe and wait */
                close(fd);
                while (wait(&status) != pid)
                    ;
                break;
        } /* switch */
        sleep(2);
        close(fd);
    } /* while */
    }  /* end of my if (pid_check... */

  else
    printf("plan already running\n");

} /* main */

void sig_handler()  /* cleanup */
{
    char *plan, *getenv();

    plan = getenv("PLAN");

    unlink(plan);
    exit(0);
}

int pid_deal()    /* function for recording pid and making sure process
           isn't already running */
{
  char savepid[100];    /* string for file name */
  FILE *sp;
  int checker;        /* return value:  0 if .planpid exists, and
               program shouldn't be run, 1 if not */
  char *home;

  home = getenv("HOME");        /* put save name for file */
  strcpy(savepid, home);        /* in savepid */
  strcat(savepid, "/.planpid");

  if ((sp = fopen(savepid, "r")) != NULL) /* test for existence of
                         .planpid by trying to open
                         the file for reading */
    checker = 0;     /* return a zero if read was successful, i.e.,
               file already exists */

  else
    checker = 1;    /* file doesn't exist, return a 1 to execute
               the rest of the program */
  fclose(sp);

  if (checker == 1)
    {
      sp = fopen(savepid, "w");
      fprintf(sp, "%d", getpid());     /* puts PID for plan into file */
      fclose(sp);
    }

  return checker;
}