Recipe 16.23 Program: sigrand

The following program gives you random signatures by using named pipes. It expects the signatures file to have records in the format of the fortune program—that is, each possible multiline record is terminated with "%%\n". Here's an example:

Make is like Pascal: everybody likes it, so they go in and change it.
                                            --Dennis Ritchie
%%
I eschew embedded capital letters in names; to my prose-oriented eyes,
they are too awkward to read comfortably. They jangle like bad typography.
                                            --Rob Pike
%%
God made the integers; all else is the work of Man.  
                                            --Kronecker
%%
I'd rather have :rofix than const.          --Dennis Ritchie
%%
If you want to program in C, program in C.  It's a nice language.
I use it occasionally...   :-)              --Larry Wall
%%
Twisted cleverness is my only skill as a programmer.       
                                            --Elizabeth Zwicky
%%
Basically, avoid comments. If your code needs a comment to be understood,
it would be better to rewrite it so it's easier to understand.  
                                            --Rob Pike
%%
Comments on data are usually much more helpful than on algorithms.  
                                            --Rob Pike
%% 
Programs that write programs are the happiest programs in the world.
                                            --Andrew Hume 
%%

We check whether we're already running by using a file with our PID in it. If sending a signal number 0 indicates that PID still exists (or, rarely, that something else has reused it), we just exit. We also look at the current Usenet posting to decide whether to look for a per-newsgroup signature file. That way, you can have different signatures for each newsgroup you post to. For variety, a global signature file is still on occasion used even if a per-newsgroup file exists.

You can even use sigrand on systems without named pipes if you remove the code to create a named pipe and extend the sleep interval before file updates. Then .signature would just be a regular file. Another portability concern is that the program forks itself in the background, which is almost like becoming a daemon. If you have no fork call, just comment it out.

The full program is shown in Example 16-12.

Example 16-12. sigrand

  #!/usr/bin/perl -w
  # sigrand - supply random fortunes for .signature file
  
  use strict;
  
  # config section variables
  use vars qw( $NG_IS_DIR $MKNOD $FULLNAME $FIFO $ART $NEWS $SIGS $SEMA
                      $GLOBRAND $NAME );
  
  # globals
  use vars qw( $Home $Fortune_Path @Pwd );
  
  ################################################################
  # begin configuration section 
  # should really read from ~/.sigrandrc
  
  gethome( );
  
  # for rec/humor/funny instead of rec.humor.funny
  $NG_IS_DIR      = 1;    
  
  $MKNOD          = "/bin/mknod";
  $FULLNAME       = "$Home/.fullname";
  $FIFO           = "$Home/.signature";
  $ART            = "$Home/.article";
  $NEWS           = "$Home/News";
  $SIGS           = "$NEWS/SIGNATURES";
  $SEMA           = "$Home/.sigrandpid";
  $GLOBRAND       = 1/4;  # chance to use global sigs anyway
  
  # $NAME should be (1) left undef to have program guess
  # read address for signature maybe looking in ~/.fullname,
  # (2) set to an exact address, or (3) set to empty string
  # to be omitted entirely.
  
  $NAME           = '';           # means no name used
  ## $NAME        = "me\@home.org\n";     
  
  # end configuration section -- HOME and FORTUNE get autoconf'd
  ################################################################
  
  setup( );                # pull in inits
  justme( );               # make sure program not already running
  fork && exit;           # background ourself and go away
  
  open(SEMA, "> $SEMA")              or die "can't write $SEMA: $!";
  print SEMA "$$\n";
  close SEMA                         or die "can't close $SEMA: $!";
  
  # now loop forever, writing a signature into the 
  # fifo file.  if you don't have real fifos, change
  # sleep time at bottom of loop to like 10 to update
  # only every 10 seconds.
  for (;;) {
      open(FIFO, "> $FIFO")                or die "can't write $FIFO: $!";
      my $sig = pick_quote( );
      for ($sig) { 
          s/^((:?[^\n]*\n){4}).*$/$1/s;   # trunc to 4 lines
          s/^(.{1,80}).*? *$/$1/gm;       # trunc long lines
      }
      # print sig, with name if present, padded to four lines
      if ($NAME) { 
          print FIFO $NAME, "\n" x (3 - ($sig =~ tr/\n//)), $sig;
      } else {
          print FIFO $sig;
      }
      close FIFO;
  
      # Without a microsleep, the reading process doesn't finish before
      # the writer tries to open it again, which since the reader exists,
      # succeeds.  They end up with multiple signatures.  Sleep a tiny bit
      # between opens to give readers a chance to finish reading and close
      # our pipe so we can block when opening it the next time.
  
      select(undef, undef, undef, 0.2);   # sleep 1/5 second
  }
  die "XXX: NOT REACHED";         # you can't get here from anywhere
  
  ################################################################
  
  # Ignore SIGPIPE in case someone opens us up and then closes the fifo
  # without reading it; look in a .fullname file for their login name.
  # Try to determine the fully qualified hostname.  Look our for silly
  # ampersands in passwd entries.  Make sure we have signatures or fortunes.
  # Build a fifo if we need to.
  
  sub setup {
      $SIG{PIPE} = 'IGNORE';              
  
      unless (defined $NAME) {            # if $NAME undef in config
          if (-e $FULLNAME) {
                      $NAME = `cat $FULLNAME`;
                      die "$FULLNAME should contain only 1 line, aborting" 
                          if $NAME =~ tr/\n// > 1;
          } else {
                      my($user, $host);
                      chop($host = `hostname`);
                      ($host) = gethostbyname($host) unless $host =~ /\./;
                      $user = $ENV{USER} || $ENV{LOGNAME} || $Pwd[0]
                          or die "intruder alert";
                      ($NAME = $Pwd[6]) =~ s/,.*//;
                      $NAME =~ s/&/\u\L$user/g; # can't believe some folks still do this
                      $NAME = "\t$NAME\t$user\@$host\n";
          } 
      }
  
      check_fortunes( ) if !-e $SIGS;
  
      unless (-p $FIFO) {         # -p checks whether it's a named pipe
          if (!-e _) {
                       system($MKNOD, $FIFO, "p") && die "can't mknod $FIFO";
                       warn "created $FIFO as a named pipe\n";
          } else {
                       die "$0: won't overwrite file .signature\n";
          } 
      } else {
          warn "$0: using existing named pipe $FIFO\n";
      } 
  
      # get a good random number seed.  not needed if 5.004 or better.
      srand(time( ) ^ ($$ + ($$ << 15)));
  }
  
  # choose a random signature
  sub pick_quote {
      my $sigfile = signame( );
      if (!-e $sigfile) {
          return fortune( );
      } 
      open(SIGS, "< $sigfile")                or die "can't open $sigfile";
      local $/  = "%%\n";
      local $_;
      my $quip;
      rand($.) < 1 && ($quip = $_) while <SIGS>;
      close SIGS;
      chomp $quip;
      return $quip || "ENOSIG: This signature file is empty.\n";
  } 
  
  # See whether ~/.article contains a Newsgroups line.  if so, see the first
  # group posted to and find out whether it has a dedicated set of fortunes.
  # otherwise return the global one.  also, return the global one randomly
  # now and then to spice up the sigs.
  sub signame {
       (rand(1.0) > ($GLOBRAND) && open ART) || return $SIGS;   
       local $/  = '';
       local $_  = <ART>;
       my($ng)   = /Newsgroups:\s*([^,\s]*)/;
       $ng =~ s!\.!/!g if $NG_IS_DIR;     # if rn -/,  or SAVEDIR=%p/%c
       $ng = "$NEWS/$ng/SIGNATURES";
       return -f $ng ? $ng : $SIGS;
  } 
  
  # Call the fortune program with -s for short flag until
  # we get a small enough fortune or ask too much.
  sub fortune {
     local $_;
     my $tries = 0;
     do { 
         $_ = `$Fortune_Path -s`; 
     } until tr/\n// < 5 || $tries++ > 20;
     s/^/ /mg;
     $_ || " SIGRAND: deliver random signals to all processes.\n";
  } 
  
  # Make sure there's a fortune program.  Search 
  # for its full path and set global to that.
  sub check_fortunes {
      return if $Fortune_Path;    # already set
      for my $dir (split(/:/, $ENV{PATH}), '/usr/games') {
          return if -x ($Fortune_Path = "$dir/fortune");
      } 
      die "Need either $SIGS or a fortune program, bailing out";
  } 
  
  # figure out our directory
  sub gethome {
      @Pwd = getpwuid($<);
      $Home = $ENV{HOME} || $ENV{LOGDIR} || $Pwd[7]
                         or die "no home directory for user $<";
  }
  
  # "There can be only one."  --the Highlander
  sub justme {
      if (open SEMA) {
          my $pid;
          chop($pid = <SEMA>);
          kill(0, $pid)              and die "$0 already running (pid $pid), bailing out";
          close SEMA;
      } 
  
  
  
  
  
  }