info2man-1.1/0040775000076400007640000000000007504412737013355 5ustar cjwatsoncjwatsoninfo2man-1.1/info2man0100755000076400007640000000042407201237432014776 0ustar cjwatsoncjwatson#!/bin/sh # # Convert info to -man format. # - Cameron Simpson 01nov2000 # xit=0 tmp=/tmp/i2m$$ info2pod ${1+"$@"} >$tmp || xit=1 # stderr tossed because of overzealous warnings pod2man --lax --center='GNU Info' $tmp 2>/dev/null || xit=1 rm -f $tmp exit $xit info2man-1.1/info2pod0100755000076400007640000000365107401255321015011 0ustar cjwatsoncjwatson#!/usr/bin/perl -w # # Convert info file into pod, largely because # # - info's too stupid to read stdin, so incorparating it # into other tools sucks # # - I want my ordinary "man" command to find info files and # do the right thing. # # - the GNU people are arrogant scum, and produce farces of # manual entries, each prefaced with "we like info, # so we don't maintain this page, and it's probably # a pack of lies - go read the info file". Of course, # the only way to do that is to fire up emacs or to # use their weird info tool, which doesn't act much # like a pager at all and violates the "use my preferred pager" # approach people should be able to expect. # # Accordingly, since the Perl people can get this right (pod converts handily # to all sorts of stuff), here is info2pod, which can be piped to pod2man # to make manual entries. # - Cameron Simpson 14nov1999 # # Request from Hamish Macintyre for this. # Real coding begins. - 20sep2000 # use strict qw(vars); use cs::Misc; use cs::Sink; use cs::GNUInfo; ## use cs::Hier; # ugly hack because info is inherently filename based # my "man" script sets $_DcoFile @ARGV=$ENV{'_DocFile'} if ! @ARGV && defined $ENV{'_DocFile'}; die "Usage: $::cmd info-file\n" if @ARGV != 1; $ARGV[0] =~ s/.(Z|gz|z|bz2)$//; my $I = new cs::GNUInfo $ARGV[0]; ## warn "I=".cs::Hier::h2a($I,1); # collect all the info files and subfiles $I->RunQueue(); ## warn "I=".cs::Hier::h2a($I,1); # attach parents to children for my $N ($I->Nodes()) { my $F = $N->Fields(); if (exists $F->{UP}) { my $supN = $I->Node($F->{UP}); if (! defined $supN) { ## warn "$::cmd: no up node named \"$F->{UP}\""; } else { $supN->AddSubNode($N); } } } my $N = $I->Node("Top"); if (! defined $N) { my $nl = $I->Nodes(); $N=$nl->[0] if @$nl; } if (defined $N) { $N->SetLevels(); } my $s = new cs::Sink(FILE,STDOUT); $I->Pod2s($s); exit 0; info2man-1.1/cs/0040775000076400007640000000000007504403702013752 5ustar cjwatsoncjwatsoninfo2man-1.1/cs/Misc.pm0100644000076400007640000000661707267177767015241 0ustar cjwatsoncjwatson#!/usr/bin/perl # # Miscellaneous routines. # - Cameron Simpson 31jul1996 # use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } require 'flush.pl'; # for ::flush() use cs::Math; package cs::Misc; ($::cmd=$0) =~ s:.*/::; undef %cs::Misc::_used_package; sub ::need { my(@pkgs)=@_; my($cp)=caller; for my $package (@pkgs) { if (! $cs::Misc::_used_package{$package}) { eval "package $cp; use $package"; die $@ if $@; $cs::Misc::_used_package{$package}=1; } } } sub ::log { my(@c)=caller; warn join('',@_)." at @c";; } ## if ($ENV{SYSTEMID} eq 'zip') ## { $cs::SiteName='zip.com.au'; ## $cs::Organisation='ZipWorld'; ## ## $cs::RootDN="o=$CISRA::Organisation, c=AU"; ## } ## elsif ($ENV{SYSTEMID} eq 'cisra') ## { ::need(CISRA::Misc); ## $cs::SiteName='zip.com.au'; ## $cs::Organisation='Canon Information Systems Research Australia'; ## $cs::RootDN="o=$CISRA::Organisation, c=AU"; ## } ## elsif ($ENV{USER} eq 'cameron') ## { $cs::SiteName='zip.com.au';; ## $cs::Organisation='ZipWorld'; ## ## $cs::RootDN="o=$CISRA::Organisation, c=AU"; ## } ## sub ::new ## { my($class)=shift; ## warn "N1($class @_)"; ## ::need($class); ## warn N2; ## new $class @_; ## } sub ::member { my($str)=shift; scalar(grep($_ eq $str,@_)); } # uniq, preserving order (drop trailing dups) sub ::uniq { ## if (! @_) ## {my(@c)=caller; warn "uniq(@_) from [@c]";} my @u; if (@_ < 2) { @u=@_; # optimisation } else { my %u; for my $k (@_) { if (! defined $k) { ## my(@c)=caller;warn "undef in uniq(@_) from [@c]"; } elsif (! exists $u{$k}) { $u{$k}=1; push(@u,$k); } } } wantarray ? @u : [ @u ]; } sub ::max { cs::Math::max(@_) } sub ::min { cs::Math::min(@_) } # merge one hash into another sub ::addHash($$) { my($h1,$h2)=@_; for my $k (keys %$h2) { $h1->{$k}=$h2->{$k}; } } # remove keys of one hash from another sub ::subHash($$) { my($h1,$h2)=@_; for my $k (keys %$h2) { delete $h1->{$k}; } } sub ::detab($;$) # (tabbed,tabsize) -> untabbed { my($line,$tabsize)=@_; $tabsize=8 if ! defined $tabsize; if (! defined $line) { ::need(cs::DEBUG); warn "\$line not defined\n"; cs::DEBUG::pstack(); die; } return '' if ! length $line; local($_); # Bug in regexps? # s/\t/' ' x ($tabsize-(length($`)%$tabsize))/eg; $_=''; ## {my(@c)=caller;warn "line=[$line] from [@c]";} for my $chunk (split(/\t/,$line)) { $_.=$chunk; $_.=(' ' x ($tabsize-(length($_) % $tabsize))); } s/[ \t]+$//; $_; } # code courtesy of Graham Barr . sub ::reftype { my $ref = shift; return undef unless ref($ref); my $type; foreach $type (qw(SCALAR ARRAY HASH CODE IO)) { return $type if UNIVERSAL::isa($ref,$type); } return undef; } sub tmpDir { defined $ENV{TMPDIR} ? $ENV{TMPDIR} : defined $ENV{TMP} ? $ENV{TMP} : -d "$ENV{HOME}/tmp/." ? "$ENV{HOME}/tmp" : "/usr/tmp"; } # generate a new file handle name $cs::Misc::_MkHandle='Handle00000'; sub mkHandle { # warn "depreciated mkHandle($oldStyle) called from [" # .join(' ',caller)."]"; my($oldStyle)=shift; $oldStyle=0 if ! defined $oldStyle; my($h)="cs::Misc::".$cs::Misc::_MkHandle++; $h =~ s/::/'/g if $oldStyle; $h; } sub editor(;$) { my($dflt)=@_; $dflt='vi' if ! defined $dflt; defined $ENV{EDITOR} ? $ENV{EDITOR} : $dflt; } 1; info2man-1.1/cs/Math.pm0100644000076400007640000000132707167262141015204 0ustar cjwatsoncjwatson#!/usr/bin/perl # # Math stuff. # - Cameron Simpson 31jul96 # use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } package cs::Math; $cs::Math::PI=3.141592653585979323; sub numeric { local($a,$b)=@_; $a <=> $b } sub lexical { local($a,$b)=@_; $a cmp $b } sub deg2rad { shift(@_)*$cs::Math::PI/180; } sub rad2deg { shift(@_)*180/$cs::Math::PI; } sub min { return undef unless @_; my($min)=shift; my($n); while (@_) { $n=shift; if ($n < $min) { $min=$n; } } $min; } sub max { return undef unless @_; ## warn "max(@_)"; my($max)=shift; my($n); while (@_) { $n=shift; if ($n > $max) { $max=$n; } } ## warn "max=$max"; $max; } 1; info2man-1.1/cs/Sink.pm0100644000076400007640000002366607224752131015226 0ustar cjwatsoncjwatson#!/usr/bin/perl # # A Sink object. # This is an object to which data may be written, with backends to # pass the data to several types of downstream object: # FILE A absolute filehandle. # APPEND A file opened for append. This becomes a FILE. # PATH A file opened for write. This becomes a FILE. # PIPE A shell pipeline to open. # ARRAY A reference to an array. Data are push()ed onto it. # SCALAR A reference to a scalar. Data are appened to it. # Sink Another Sink-like object. # A Sink does _not_ provide an inherent buffering. # XXX: this may change with the async extensions. # # Methods: # new type args # Make a new cs::Sink of one of the types above. # Args are: # FILE Reference to a FILE. # APPEND Pathname. # PATH Pathname. # ARRAY Reference to an array. # SCALAR Reference to a scalar. # Sink Reference to a Sink. # Returns undef on failure. # Flush # Call the Flush method of the downstream object, if any. # Write data # Call the Write method of the downstream object. # Returns the number of bytes written, or undef on error. # NOTE: if less than the full data are written, the caller # must be prepared to deal with the unwritten portion. # Put @data # Iterate over Write until all items in @data are written. # Suck [n] # Called by the downstream object if it wants "free" data. # This is primarily to assist asynchronous I/O. # At most n bytes of data are returned, if n > 0. # It will call the upstream object's Suck routine at need # if one is registered. # SuckFrom ref # Register ref as the upstream object whose Suck method can # be called from "free" data. # =head1 NAME cs::Sink - a data sink =head1 SYNOPSIS use cs::Sink; =head1 DESCRIPTION The cs::Sink module provides generic data sink facilities. Bs may be created which wire to a variety of objects. =cut use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use cs::Misc; use cs::IO; require 'flush.pl'; package cs::Sink; $cs::Sink::_UseIO=$cs::IO::_UseIO; if ($cs::Sink::_UseIO) { ::need(IO); ::need(IO::File); ::need(IO::Handle); } =head1 GENERAL FUNCTIONS =over 4 =item put(I, I) Creates a new B using the arguments in the array references by I and writes the I to it. Returns B on error. =cut sub put { my($args)=shift; my($s)=new cs::Sink @$args; return undef if ! defined $s; $s->Put(@_); } =back =head1 OBJECT CREATION =over 4 =item open(I) Create a new sink attached to the file named in I. =cut sub open { new cs::Sink (PATH,@_); } =item new cs::Sink (I,I) Create a new sink of the specified I. I varies according to the type: =over 6 =cut sub new { my($class,$type)=(shift,shift); my($this)={}; my(@c)=caller; ## main::carp "new Sink (class=$class, type=$type, @=[@_])"; $this->{CALLER}=[ @c ]; $this->{FLAGS}=0; $this->{BUF}=''; # only used in asynchronous mode if ($type eq ASYNC) { $this->{FLAGS}|=cs::IO::F_ASYNC; $type=shift; } =item B, I Attach to the filehandle I. Flushes any pending output in I as a side-effect. =cut if ($type eq FILE) { my($FILE)=shift; ::flush($FILE); $this->{IO}=($cs::Sink::_UseIO ? new_from_fd IO::Handle (fileno($FILE),"w") : $FILE); $this->{FLAGS}|=$cs::IO::F_NOCLOSE; $this->{FILE}=$FILE; } =item B, I Attach to the file named by I in append mode. =cut elsif ($type eq APPEND) { my($path,$complex)=@_; $complex=0 if ! defined $complex; my($io,$Fpath)=_new_FILE($path,1,$complex); return undef if ! defined $io; $this->{IO}=$io; $this->{PATH}=$Fpath; # debugging $type=FILE; } =item B, I Attach to the file named in I in rewrite mode. =cut elsif ($type eq PATH) { my($path,$complex)=@_; $complex=0 if ! defined $complex; my($io,$Fpath)=_new_FILE($path,0,$complex); return undef if ! defined $io; $this->{IO}=$io; $this->{PATH}=$Fpath; # debugging $type=FILE; } =item B, I Attach to a pipe to the shell command I. =cut elsif ($type eq PIPE) { my($pipeline)="| ".shift(@_)." "; my($io); $io=($cs::Sink::_UseIO ? new IO::File : cs::IO::mkHandle()); return undef if ! ($cs::Sink::_UseIO ? $io->open($pipeline) : CORE::open($io,$pipeline)); $this->{IO}=$io; $type=FILE; } =item B, I Attach to the array referenced by I. Each B to the sink pushes a single string onto the array. =cut elsif ($type eq ARRAY) { $this->{ARRAY}=shift; } =item B, I Attach to the scalar referenced by I. Each B appends to the scalar. =cut elsif ($type eq SCALAR) { $this->{SCALAR}=shift; } =item B, I Attach to the B object I. Typically used by subclasses to apply a filter to data before depositing in I. =cut elsif ($type eq Sink) { $this->{DS}=shift; } else { warn "cs::Sink::new: unknown type \"$type\""; return undef; } $this->{TYPE}=$type; bless $this, $class; if (exists $this->{IO} && ($this->{FLAGS}&$cs::IO::F_ASYNC)) { cs::IO::selAddSink($this); } $this; } =back =item tmpSink(I) Create a new sink object attached to a new temporary file allocated by B)>. =cut sub tmpSink { ::need(cs::Pathname); new cs::Sink (PATH, cs::Pathname::tmpnam(@_)); } $cs::Sink::_new_FILE_first=1; sub _new_FILE { my($path,$append,$complex)=@_; $complex=0 if ! defined $complex; ## warn "Sink::_new_FILE(@_) ...\n"; my($f,@f); # real path, filter list ($f,@f)=($complex ? cs::IO::choose($path,$append ? '' : undef) : $path); if ($append && @f) { warn "tried to append to \"$f\" [@f]"; return undef; } my($io)=cs::IO::openW($append,$f,@f); defined $io ? wantarray ? ($io,$f) : $io : wantarray ? (undef,undef) : undef; } sub DESTROY { _DESTROY(@_); } sub _DESTROY { my($this)=shift; return if ! exists $this->{TYPE}; # already destroyed my($type)=$this->{TYPE}; ## warn "Sink::DESTROY($this)\n"; $this->Flush(); if (! $cs::Sink::_UseIO && $type eq FILE && ! ($this->{FLAGS} & $cs::IO::F_NOCLOSE)) { ## warn "CLOSE($this->{IO})"; close($this->{IO}) || warn "$::cmd: close($this->{IO}): $!"; } else { ## warn "$::cmd: not try to close ".cs::Hier::h2a($this).", made from [@{$this->{CALLER}}]"; } delete $this->{TYPE}; } =back =head1 OBJECT METHODS =over 4 =item Path() For sinks attached to files, return the pathname of the file. =cut sub Path($) { my($this)=shift; return undef if ! exists $this->{PATH}; $this->{PATH}; } =item Handle() For sinks attached to files or filehandles, return the filehandle. =cut sub Handle($) { my($this)=@_; exists $this->{IO} ? $this->{IO} : undef; } =item Put(I) Write all the I to the sink. =cut sub Put { my($this)=shift; my($alln)=0; my($n); my($data)=join('',@_); WRITE: while (length $data) { $n=$this->Write($data); if (! defined $n) { my@c=caller; warn "$::cmd: write error (possibly $!), aborting with\n\t\t[$data]\n\tunwritten\n\tfrom [@c]"; return undef; } $alln+=$n; substr($data,$[,$n)=''; } $alln; } sub PollOut { my($this)=@_; return 0 if ! length $this->{BUF}; my($n); local($_)=''; $n=$this->{IO}->syswrite($this->BUF,length($this->{BUF})); return undef if ! defined $n; substr($this->{BUF},$[,$n)=''; length; } sub Write { my($this,$datum)=@_; my($type)=$this->{TYPE}; my($io)=$this->{IO}; my($n)=length $datum; if ($type eq FILE) { die "UseIO is back on!" if $cs::Sink::_UseIO; if (! print $io $datum) { undef $n; warn "print $io \$datum: errno=$!"; } ## # XXX - IO module doesn't like zero sized writes ## if ($n > 0 || ! $cs::Sink::_UseIO) ## { $n=($cs::Sink::_UseIO ## ? $io->syswrite($datum,$n) ## : $this->{FLAGS}&$cs::IO::F_RAWWRITES ## ? syswrite($io,$datum,$n) ## : (print $io $datum) ## ? $n : undef); ## } } elsif ($type eq Sink) { $n=$this->{DS}->Write($datum); } elsif ($type eq ARRAY) { push(@{$this->{ARRAY}},$datum); } elsif ($type eq SCALAR) { ${$this->{SCALAR}}.=$datum; } if (! defined $n) { my@c=caller; warn "\$n undef! type=[$type] FILE=[$this->{FILE}]\n\tfrom [@c]"; return undef; } $n; } sub Flush { my($this)=shift; my($type)=$this->{TYPE}; if ($type eq FILE) { ::flush($this->{IO}); } elsif ($type eq ARRAY || $type eq SCALAR) {} elsif ($type eq Sink) { $this->{DS}->Flush(); } else { warn "$::cmd: operation Flush not supported on cs::Sink/$type objects"; } } # take note of where to suck from sub SuckFrom { my($this,$src)=@_; $this->{SUCKFROM}=$src; } # retrieve any "free" data # this is the SUCKFROM callback from the downstream module sub Suck { my($this,$n)=@_; my($type)=$this->{TYPE}; my($datum)=''; if ($type eq FILE || $type eq Sink) {} elsif ($type eq ARRAY) { $datum=shift(@{$this->{ARRAY}}) if @{$this->{ARRAY}}; } elsif ($type eq SCALAR) { my($len)=length ${$this->{SCALAR}}; if ($n == 0 || $n > $len) { $n=$len; } $datum=substr(${$this->{SCALAR}},$[,$n); substr(${$this->{SCALAR}},$[,$n)=''; } else { cs::Upd::err("operation Suck not supported on Sink/$type objects\n"); $datum=undef; } # no free data, check for some upstream if (! length $datum && defined $this->{SUCKFROM}) { $datum=$this->{SUCKFROM}->Suck($n); } # if the free datum is too big, cut it back if ($n > 0 && length $datum > $n) { my($buf)=substr($datum,$[+$n); substr($datum,$[+$n)=''; $this->_Blow($buf); } $datum; } # push data back onto the stream for later sub _Blow { my($this,$datum)=@_; my($type)=$this->{TYPE}; if ($type eq ARRAY){ unshift(@{$this->{ARRAY}},$datum); } else { die "no unsuck op for Sink/$type"; } } =back =head1 SEE ALSO cs::Source(3), cs::Pathname(3) =head1 AUTHOR Cameron Simpson Ecs@zip.com.auE =cut 1; info2man-1.1/cs/IO.pm0100644000076400007640000002170007222512225014610 0ustar cjwatsoncjwatson#!/usr/bin/perl # # General routines built on Sinks and Sources. # - Cameron Simpson # use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use cs::Misc; use cs::Pathname; package cs::IO; $cs::IO::_UseIO=0; $cs::IO::F_ASYNC=0x01; $cs::IO::F_NOCLOSE=0x02; # no close on Sink/Source DESTROY $cs::IO::F_STICKYEOF=0x04; $cs::IO::F_HADEOF=0x08; $cs::IO::F_RAWWRITES=0x10; # print instead of syswrite if ($cs::IO::_UseIO) { ::need(IO); ::need(IO::Select); $cs::IO::_Selection=new IO::Select; undef %cs::IO::_SourceSelection; # bound to an IO::Handle undef %cs::IO::_SourceTable; # not bound - use HasData method undef %cs::IO::_SinkSelection; } sub selAddSource { die "selAddSource(@_)" if ! $cs::IO::_UseIO; my($s)=@_; my($type)=$s->{TYPE}; if (! ($s->{FLAGS}&$cs::IO::F_ASYNC)) { my(@c)=caller; die "not an asynchronous cs::Source [".cs::Hier::h2a($s)."] from [@c]"; } if ($type eq FILE) { $cs::IO::_Selection->add($s->{IO}); $cs::IO::_SourceSelection{$s->{IO}->fileno()}=$s; } else { $cs::IO::_SourceTable{"$s"}=$s; } } sub selAddSink { die "selAddSink(@_)" if ! $cs::IO::_UseIO; my($s)=@_; my($type)=$s->{TYPE}; if (! ($s->{FLAGS}&$cs::IO::F_ASYNC)) { my(@c)=caller; die "not an asynchronous cs::Sink [".cs::Hier::h2a($s,0)."] from [@c]"; } if ($type eq FILE) { $cs::IO::_Selection->add($s->{IO}); $cs::IO::_SinkSelection{$s->{IO}->fileno()}=$s; } else { $cs::IO::_SinkTable{"$s"}=$s; } } sub selDelSource { die "selDelSource(@_)" if ! $cs::IO::_UseIO; my($s)=@_; my($type)=$s->{TYPE}; if ($type eq FILE) { $cs::IO::_Selection->remove($s->{IO}); delete $cs::IO::_SourceSelection{$s->{IO}->fileno()}; } else { delete $cs::IO::_SourceTable{"$s"}; } } sub selDelSink { die "selDelSink(@_)" if ! $cs::IO::_UseIO; my($s)=@_; my($type)=$s->{TYPE}; if ($type eq FILE) { $cs::IO::_Selection->remove($s->{IO}); delete $cs::IO::_SinkSelection{$s->{IO}->fileno()}; } else { delete $cs::IO::_SinkTable{"$s"}; } } sub poll { die "poll(@_)" if ! $cs::IO::_UseIO; my($rd,$wr)=([],[]); my($didio)=0; my(@f,$s); print STDERR "poll ...\n"; # collect waiting data @f=keys %cs::IO::_SourceSelection; if (@f) { for ($cs::IO::_Selection->can_read(@f)) { $s=$cs::IO::_SourceSelection->{$_}; push(@$rd,$s); $s->PollIn() && $didio++; } } @f=keys %cs::IO::_SourceTable; if (@f) { for (@f) { if ($cs::IO::_SourceTable{$_}->HasData()) { $cs::IO::_SourceTable{$_}->PollIn() } } } # dispatch pending data @f=keys %cs::IO::_SinkSelection; if (@f) { for ($cs::IO::_Selection->can_write(@f)) { $s=$cs::IO::_SinkSelection->{$_}; push(@$wr,$s); $s->PollOut() && $didio++; } } # return lists or total active wantarray ? ($rd,$wr) : $didio; } undef %cs::IO::_DirPrefs; @cs::IO::_Filters=qw(Z gz pgp); # in order of preference and application %cs::IO::_Filter=('Z' => { TYPE => COMPRESS, EXT => 'Z', TO => 'compress', FROM => 'uncompress', }, 'bz2' => { TYPE => COMPRESS, EXT => 'bz2', TO => 'bzip2 -9', FROM => 'bunzip2', }, 'gz' => { TYPE => COMPRESS, EXT => 'gz', TO => 'gzip -9', FROM => 'gunzip', }, 'pgp' => { TYPE => ENCRYPT, EXT => 'pgp', TO => 'pgp -fe "$PGPID"', FROM => 'pgp -fd', }, ); sub dupR { _dup('<',shift); } sub dupW { _dup('>',shift); } sub _dup { my($io,$handle)=@_; my($newhandle)=mkHandle(); open($newhandle,"$io&$handle") ? $newhandle : $handle; } # take a target filename and some preferences # and return actual name and filters chosen (ordered) # prefs is undef or "filter,filter,..." (unordered) # sub choose # (filename,prefs) -> (chosen-name,filters[ordered]) { my($basefile,$prefs)=@_; warn "basefile not set" if ! defined $basefile; # see if it's already there my($match); my(@filters); if (-e $basefile && ! -d $basefile) { $match=$basefile; @filters=(); } else # look for shortest basefile(.ext)+ # where every ext is a known filter { my(@matches)=<$basefile.*>; local($_); MATCH: for my $m (sort { length($a) <=> length ($b) } # fewest filters hack @matches) { $_=$m; $_=substr($_,$[+length($basefile)); next MATCH unless /^\./ && ! /\.$/; @filters=(); TOKEN: while (/^(\.+|[^.]+)/) { if ($& eq '.') { } elsif (! defined $cs::IO::_Filter{$&}) { next MATCH; } else { push(@filters,$&); } $_=$'; } if (! length) { $match=$m; last MATCH; } } } if (defined $match) { return ($match,@filters); } # missing? generate target name from preferences # leave create/open to caller # collect preferences my(@prefs)=(); if (defined $prefs) { @prefs=_a2preflist($prefs); } else # use prefs from dir { my($dir)=cs::Pathname::dirname($basefile); my($prefs)="$dir/.ioprefs"; if (defined $cs::IO::_DirPrefs{$dir}) { @prefs=_a2preflist($cs::IO::_DirPrefs{$dir}); } else { # load special preferences if (open(IOP,"< $prefs\0")) { @prefs=_a2preflist(join('',)); close(IOP); } $cs::IO::_DirPrefs{$dir}=join(',',@prefs); } } my(%ispref,%types,@trypref); map($ispref{$_}=1,@prefs); # make filename with preferred extensions $match=$basefile; # for each filter in order for (@cs::IO::_Filters) { # if wanted and not already redundant if ($ispref{$_} && ! $types{$cs::IO::_Filter{$_}->{TYPE}}) { push(@filters,$_); $match.=".$_"; # record type of filter selected $types{$cs::IO::_Filter{$_}->{TYPE}}=1; } } ($match,@filters); } sub _a2preflist { grep(length,split(/[\s,]+/,shift)); } sub mkHandle { cs::Misc::mkHandle(@_) } sub tmpnam { my(@c)=caller; warn "forwarding tmpnam(@_) to cs::Pathname::tmpnam from [@c]"; ::need(cs::Pathname); cs::Pathname::tmpnam(@_); } sub tmpfile { my($tmpnam); my($FILE)=mkHandle(); return undef if ! defined ($tmpnam=tmpnam()); if (! open($FILE,">+ $tmpnam")) { warn "open($tmpnam,update): $!"; return undef; } unlink($tmpnam) || warn "unlink($tmpnam): $!"; $FILE; } sub openR { my($file,@filters)=@_; return undef if ! -e $file; my($io); if ($cs::IO::_UseIO) { $io=new IO::File; } else { $io=mkHandle(); } my($openstr)=$file; if (! @filters) # short open - tidy up name { if ($openstr !~ m:^/:) { $openstr="./$openstr"; } $openstr="< $openstr\0"; } else # construct shell pipeline { # quote filename $openstr =~ s:':'\\'':g; $openstr=" <'$openstr'"; FILTER: for (reverse @filters) { if (! defined $cs::IO::_Filter{$_}) { warn "openR(@_): ignoring unknown filter \"$_\""; next FILTER; } $openstr.=" $cs::IO::_Filter{$_}->{FROM} |"; } # warn "_openR(@_): [$openstr]"; } ($cs::IO::_UseIO ? $io->open($openstr) : open($io,$openstr)) ? $io : undef; } sub openW { my($append,$file,@filters)=@_; my($io); if ($cs::IO::_UseIO) { $io=new IO::File; } else { $io=mkHandle(); } my($openstr)=$file; my($openmode)=($append ? '>>' : '>'); if (! @filters) # short open - tidy up name { if ($openstr !~ m:^/:) { $openstr="./$openstr"; } $openstr="$openmode $openstr\0"; } else # construct shell pipeline { # quote filename $openstr =~ s:':'\\'':g; $openstr="$openmode'$openstr'"; FILTER: for (reverse @filters) { if (! defined $cs::IO::_Filter{$_}) { warn "IO::_openW(@_): ignoring unknown filter \"$_\""; next FILTER; } $openstr="| $cs::IO::_Filter{$_}->{TO} $openstr"; } # print STDERR "openW(@_): \"$openstr\"\n"; } ($cs::IO::_UseIO ? $io->open($openstr) : open($io,$openstr)) ? $io : undef; } # return a filehandle open for read/write # normally the handle will be attached to an unlinked file # in the specified directory sub cacheFile # dir[,unlink] -> (filehandle[,path]) { my($dir,$unlink)=@_; $unlink=1 if ! defined $unlink; $dir=cacheDir() if ! defined $dir; # delimit leading whitespace $dir="./$dir" if $dir =~ /^\s/; my($F)=mkHandle(); my($n,$s,$f); N: for ($n=1; 1; $n++) { $f="$dir/$n"; # if (-e $f) { system("ls -ld $f"); } next N if -e $f; last N if open($F,"+> $f\0"); my($err)="$!"; next N if -e $f; warn "open(+>$f): $err"; return undef; } if ($unlink && ! unlink($f)) { warn "cacheFile(): unlink($F): $!"; } wantarray && ! $unlink ? ($F,$f) : $F; } sub cacheDir { my($dir); $dir=cs::Misc::tmpDir()."/Cache"; if (! -d "$dir/." && ! mkdir($dir,0777)) { warn "mkdir($dir): $!"; } $dir; } sub fionread { my($F)=@_; eval "require 'sys/filio.ph'"; die $@ if $@; my($n,$i); my($ctl)=&FIONREAD; print "ctl=$ctl\n"; $i=''; if (! defined ($n=ioctl($F,$ctl,$i))) { warn "ioctl($F,FIONREAD,..): $!"; return undef; } print STDERR "n=$n, i=$i\n"; $n; } 1; info2man-1.1/cs/Pathname.pm0100644000076400007640000001715007324217555016055 0ustar cjwatsoncjwatson#!/usr/bin/perl # # Routines to manipulate pathnames, mostly lexical. # - Cameron Simpson 24oct95 # use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use POSIX; use cs::Misc; package cs::Pathname; # unique ID for file sub pathid($) { my($path)=@_; my @s = lstat($path); return undef if ! @s; "$s[0]:$s[1]"; } sub dirents($) { my($dir)=@_; my(@e); return () if ! opendir(D,$dir); @e=grep(length && $_ ne '.' && $_ ne '..', readdir(D)); closedir(D); @e; } sub dirname($) { local($_)=@_; if (m|(.*[^/])/+|) { $_=$1; } elsif (m|^/+|) { $_='/'; } else { $_='.'; } $_; } sub basename($) { local($_)=@_; $_=norm($_); s:.*/([^/]):$1:; $_; } sub catpath($$) { my($dir,$path)=@_; return $path if ! length $dir; "$dir/$path"; } sub absname($$) { my($path,$dir)=@_; return $path if $path =~ m:^/:; return catpath($dir,$path); } # safe rename - doesn't tromp target file if present sub saferename # (from,to) -> success { my($from,$to,$noremove)=@_; $noremove=0 if ! defined $noremove; my $ok = 0; if (link($from,$to)) { $ok=1; if (!$noremove && !unlink($from)) { warn "unlink($from): $!, $from still linked to $to\n"; } } elsif ($! == &POSIX::EXDEV) # cross device link { if (lstat($to)) { warn "$main::cmd: $to exists\n"; } else { if (!open(RENAME_FROM,"<$from")) { warn "$main::cmd: can't open $from for read: $!\n"; } else { if (!open(RENAME_TO,">$to")) { warn "$main::cmd: can't open $to for write: $!\n"; } else { $ok=1; while () { if (! print RENAME_TO) { warn "$::cmd: cs::Pathname::saferename($from,$to): $!"; $ok=0; } } close(RENAME_TO); if ($ok && ($noremove || unlink($from))) { } else { $ok=0; warn "$main::cmd: can't unlink $from ($!), unlinking $to\n"; if (!unlink($to)) { warn "$main::cmd: can't unlink $to: $!\n\tboth $from and $to now exist\n"; } } } close(RENAME_FROM); } } } else { warn "$main::cmd: link($from,$to): $!\n"; } return $ok; } sub firstfile # (base,exts...) -> first non-empty file base.ext { my($base,@exts)=@_; my($e,$f); for $e (@exts) { return $base.$e if -s $base.$e; } return undef; } # parse . and .. entries sub norm # path -> norm-path { my($path)=@_; my($pfx,@pieces); $path =~ m|^/*|; $pfx=$&; $path=$'; @pieces=grep(length,split(m|/+|,$path)); my(@path); for (@pieces) { if ($_ eq '' || $_ eq '.') {} elsif ($_ eq '..') { pop(@path); } else { push(@path,$_); } } $path=$pfx.join('/',@path); $path='.' if ! length $path; $path; } undef $cs::Pathname::_Pwd; sub pwd { if (! defined $cs::Pathname::_Pwd) { $cs::Pathname::_Pwd=`pwd`; if ($? != 0) { undef $cs::Pathname::_Pwd; return undef; } chomp $cs::Pathname::_Pwd; } $cs::Pathname::_Pwd; } sub cd { if (! chdir(@_)) { warn "$::cmd: chdir(@_): $!"; return undef; } undef $cs::Pathname::_Pwd; 1; } sub fullpath # path -> fullpath { my($path)=@_; if ($path !~ m|^/|) { my($pwd)=&pwd; return $path if ! defined $pwd; chomp($pwd); $pwd.='/' unless $pwd =~ m|/$|; $path=$pwd.$path; } norm($path); } sub ident # path or stat-array -> undef or ident { my(@s)=@_; if (@s == 1) { return undef if ! (@s=stat(shift(@s))); } "$s[6]:$s[0]:$s[1]"; } sub makedir($;$$); sub makedir($;$$) { my($dir,$perms,$verbose)=@_; $perms=0777 if ! defined $perms; $verbose=0 if ! defined $verbose; return 1 if -d "$dir/."; my($super)=cs::Pathname::dirname($dir); makedir($super,$perms) || return 0; warn "mkdir $dir\n" if $verbose; if (! mkdir($dir,$perms)) { warn "$::cmd: mkdir($dir): $!\n"; return 0; } 1; } sub needfiledir($;$) { my($file)=shift; ## warn "needfiledir($file)\n"; makedir(dirname($file),$_[0]); } sub untilde { local($_)=shift; /^~/ || return $_; length($`) ? userdir($`) : $ENV{HOME}; } sub userdir { my($u)=shift; my(@pw); if (! defined $cs::Pathname::_PwEnts{$u}) { $cs::Pathname::_PwEnts{$u}=[ getpwnam($u) ]; if (! @{$cs::Pathname::_PwEnts{$u}}) { warn "$::cmd: userdir($u): who is $u?"; } } @pw=@{$cs::Pathname::_PwEnts{$u}}; return undef unless @pw; $pw[7]; } # rename a bunch of files in a directory sub vrename { my($dir,$map,$verbose)=@_; $dir='.' if ! length $dir; $dir.='/' unless $dir =~ m:/$:; $verbose=1 if ! defined $verbose; ::need(cs::Upd) if $verbose; my(@now)=keys %$map; my(@errs)=(); my($from,$to); local($_); # normalise pathnames # assumes no collisions (i.e. no "a" and "dir/a") for (@now) { if (! m:^/:) { $from="$dir$_"; if (exists $map->{$from}) { push(@errs, "both \"$_\" and \"$from\" in map, losing \"$from\" => \"$map->{$from}\""); } $map->{$from}=$map->{$_}; delete $map->{$_}; } else { $from=$_; } $to=$map->{$from}; if ($to !~ m:^/:) { $map->{$from}="$dir$to"; } } my($err); # shuffle files @now=sort { $a <=> $b } keys %$map; MOVE: while (@now) { $from=shift(@now); next MOVE if ! exists $map->{$from}; $to=$map->{$from}; delete $map->{$from}; next MOVE if $from eq $to; $verbose && ::out("$from => $to"); if (-e $to) { if (! exists $map->{$to}) # terminal - bitch and skip { $err="\"$to\" exists, cancelling move of \"$from\""; $verbose && ::err("$err\n"); push(@errs,$err); } else { my($prefrom)=cs::Pathname::tmpnam($dir); my($preto)=$map->{$to}; delete $map->{$to}; if (-e $prefrom) { $err="\"$prefrom\" exists, cancelled move of \"$to\" and thus of \"$from\""; $verbose && ::err("$err\n"); push(@errs,$err); } elsif (! saferename($to,$prefrom)) { $err="saferename(\"$to\",\"$prefrom\"): $!: cancelled move of \"$to\" and thus of \"$from\""; $verbose && ::err("$err\n"); push(@errs,$err); } else { $verbose && ::out("$to => $prefrom"); # move this from tmp spot to final later $map->{$prefrom}=$preto; push(@now,$prefrom); # reschedule for another go now the way is clear $map->{$from}=$to; unshift(@now,$from); } } } elsif (! saferename($from,$to)) { $err="saferename(\"$from\",\"$to\"): $!"; $verbose && ::err("$err\n"); push(@errs,$err); } else { } } # just return errors in array context return @errs if wantarray; # otherwise warn and return boolean @errs == 0; } $cs::Pathname::_tmpnamSeq=0; sub tmpnam { my($tmpdir)=@_; $tmpdir=cs::Misc::tmpDir() if ! defined $tmpdir; my($tmpnam); while (1) { $tmpnam="$tmpdir/tmp$$.".$cs::Pathname::_tmpnamSeq++; if (! -e $tmpnam) { ## warn "tmpnam returns \"$tmpnam\""; return $tmpnam; } } } sub cpperm($$) { my($src,$dest)=@_; my $ok = 1; my @s = stat($src); if (! @s) { warn "$::cmd: stat($src): $!\n"; $ok=0; } else { my $perms = $s[2] & 07777; my $setid = $s[2] & 07000; if ($setid != 0) # check ownerships { my @d = stat($dest); if (! @d) { warn "$::cmd: stat($dest): $!\n"; $ok=0; } else { if (($setid & 04000) && $s[4] != $d[4] || ($setid & 02000) && $s[5] != $d[5]) { if (! chown($s[4],$s[5],$dest)) { warn "$::cmd: $src is set[ug]id but can't make ownership match on $dest: $!\n\tdropping set[ug]id bits\n"; $perms&=~06000; $ok=0; } } } } if (! chmod($perms,$dest)) { warn "$::cmd: chmod($dest,".sprintf("0%04o",$perms)."): $!\n"; $ok=0; } } $ok; } =back =head1 AUTHOR Cameron Simpson Ecs@zip.com.auE =cut 1; info2man-1.1/cs/GNUInfo.pm0100644000076400007640000001434307332146121015553 0ustar cjwatsoncjwatson#!/usr/bin/perl # # cs::GNUInfo: a module for parsing GNU info files. # - Cameron Simpson 22sep2000 # =head1 NAME cs::GNUInfo - parse and transcribe GNU info files =head1 SYNOPSIS use cs::GNUInfo; =head1 DESCRIPTION The B module parses GNU info(1) files and will transcribe them to perlpod(1) format for ready conversion to other useful formats. =cut use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use cs::Pathname; use cs::Source; use cs::GNUInfo::Node; package cs::GNUInfo; require Exporter; @cs::GNUInfo::ISA=qw(); $cs::GNUInfo::DoDebug=defined($ENV{DEBUG_GNUINFO}) && length($ENV{DEBUG_GNUINFO}); sub dbg { return $cs::GNUInfo::DoDebug if ! @_; local($_)="@_"; chomp; warn "$_\n" if $cs::GNUInfo::DoDebug; } =head1 GENERAL FUNCTIONS =over 4 =item parseTypeLine(I) Extract the block type and following parameters from the header line of an info block. Returns an array of B<(I,I,I,I,I,...)>. =cut sub parseTypeLine($) { local($_)=@_; my $type; my %fields; /^[^:]*/; $type=uc($&); while (/^([^:]+):\s*([^,]+)(,\s*)?/) { my($op,$arg)=(uc($1),$2); $_=$'; $fields{$op}=$arg; } dbg("parseTypeLine: type=$type, fields=[".join("|",%fields)."]"); ($type,\%fields); } =back =head1 OBJECT CREATION =over 4 =item new cs::GNUInfo I Instantiate a new B object based upon the named I. =cut sub new($$) { my($class,$file)=@_; my $dir = cs::Pathname::dirname($file); $file=cs::Pathname::absname($file,$dir); my $this= bless { ROOTFILE => $file, # context ROOTDIR => $dir, FILEQUEUE => [], # pending files FILESEEN => {}, # files queued before NODEMAP => {}, # node mapping NODELIST => [], # node list NAME => cs::Pathname::basename($file), }, $class; $this->NoteFile($file); $this; } =back =head1 OBJECT METHODS =over 4 =item RunQueue() After instantiation the object is initially empty, with the named file queued for processing (via the B method below). This method processes every queued file, which should result in processing of the entire info section because subsidiary files are queued during this procedure and processed before return. =cut sub RunQueue($) { my($this)=@_; my $Q = $this->{FILEQUEUE}; FILE: while (@$Q) { my $file = shift(@$Q); dbg("RunQueue $file ...\n"); my $s = new cs::Source(PATH,$file,1); if (! defined $s) { warn "$::cmd: can't open $file: $!\n"; next FILE; } $this->ParseSource($s,$file); } } =item NoteFile(I) Queue the named I for processing. I is resolved into a full pathname with respect to the root file of the object. =cut sub NoteFile($$) { my($this,$file)=@_; $file=cs::Pathname::absname($file,$this->{ROOTDIR}); if (! exists $this->{FILESEEN}->{$file}) { dbg("NoteFile($file)"); push(@{$this->{FILEQUEUE}}, $file); $this->{FILESEEN}->{$file}=1; } } =item ParseSource(I,I) Read lines from the B object I (associated with the file I), assembling them into info structures: text, menus, etc. =cut sub ParseSource($$$) { my($this,$s,$fname)=@_; local($_); BLOCK: while (defined($_=$s->GetLine()) && length) { if (/^\037$/) # commence block { # get header line if (! defined ($_=$s->GetLine()) || ! length) # end of file { dbg("EOF"); last BLOCK; } # commence next block if (/^\037$/) { $s->UnGet($_); next BLOCK; } chomp; my($type,$F)=parseTypeLine($_); my $N = new cs::GNUInfo::Node $type; $N->Fields($F); if (exists $F->{NODE}) { dbg("Nodename is \"$F->{NODE}\""); $N->Name($F->{NODE}) } my $data = $N->Data(); LINE: while (defined ($_=$s->GetLine()) && length) { # beginning of next block if (/^\037$/) { $s->UnGet($_); last LINE; } if ($type eq FILE) { ## dbg("FILE: addline $_"); $N->AddLine($_,$s,$fname); } elsif ($type eq INDIRECT) { $this->_LineINDIRECT($_,$s,$fname,$F,$data); } else { chomp; dbg("$type: push \"$_\""); push(@$data, $_); } } my $nd = scalar(@$data); dbg("AddNode type=$type"); $this->AddNode($N); } else # lines outside structure - ignore { dbg("SKIP: $_"); } } $s->UnGet($_) if defined && length; } sub _LineINDIRECT($$$$$) { my($this)=shift; local($_)=shift; my($s,$fname,$F,$data)=@_; # file: byte offset if (/^([^:]+):\s*\d+$/) { $this->NoteFile($1); } else { warn "$::cmd: $fname: unparsed INDIRECT block line: $_\n"; push(@$data,$_); } } sub AddNode($$) { my($this,$N)=@_; # back reference $N->Info($this); my $nl = $this->Nodes(); push(@$nl, $N); my $name = $N->Name(); if (defined $name) { my $nm = $this->NodeMap(); if (exists $nm->{$name}) { warn "$::cmd: AddNode(): repeated nodes named \"$name\", keeping last"; } $nm->{$name}=$N; } $N; } sub Nodes($) { my($this)=@_; my $nl = $this->{NODELIST}; wantarray ? @$nl : $nl; } sub NodeMap($) { my($this)=@_; my $nm = $this->{NODEMAP}; wantarray ? %$nm : $nm; } =item Node(I) Return the B object for the supplied I. =cut sub Node($$) { my($this,$name)=@_; my $nm = $this->NodeMap(); return undef if ! exists $nm->{$name}; $nm->{$name}; } =item Pod2s(I) Write a perlpod(1) transcription of the info object to the B object I. =cut sub Pod2s($$) { my($this,$s)=@_; $s->Put("=head1 NAME\n\n".$this->{NAME}." - $this->{NAME}\n\n"); local($_); local (%::SeenNode); my $neednl=0; my $nl = $this->Nodes(); NODE: for my $N (@$nl) { my $type = $N->Type(); if ($type eq FILE) { $N->Pod2s($s); } elsif (grep($_ eq $type, "INDIRECT", "TAG TABLE","END TAG TABLE")) { dbg("skip node of type \"$type\""); } else { warn "$::cmd: Pod2s(): unhandled node type \"$type\""; } } } =back =head1 BUGS "B<*note>" tags spanning two lines are not recognised, and remain in the text. =head1 SEE ALSO info2pod(1), info2man(1), pod2man(1), perlpod(1) =head1 AUTHOR Cameron Simpson Ecs@zip.com.auE =cut 1; info2man-1.1/cs/Source.pm0100644000076400007640000003420007426357350015554 0ustar cjwatsoncjwatson#!/usr/bin/perl # # A class to fetch data from things. # Supports _only_ sequential reading or skipping. # The base method to be overridden by subclasses is Read. # The fields TYPE, BUF and POS are used. # - Cameron Simpson 15may96 # # Added Seek() and Seekable(). # They may need overriding if you implement a seekable subclass. # - cameron, 29mar97 # # Added asynchronous interface. # - cameron, 19apr97 # # Added fetch call. # - cameron, 04jun1997 # use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use cs::Misc; use cs::IO; package cs::Source; $cs::Source::_UseIO=$cs::IO::_UseIO; $cs::Source::_BUFSIZ=8192; if ($cs::Source::_UseIO) { ::need(IO); ::need(IO::File); ::need(IO::Handle); ::need(IO::Seekable); } sub fetch { my($s)=new cs::Source @_; return undef if ! defined $s; $s->Fetch(); } sub Fetch { my($s)=@_; my(@a)=$s->GetAllLines(); return @a if wantarray; join('',@a); } sub open { new cs::Source (PATH,@_); } sub new { my($class,$type)=(shift,shift); my($this)={}; my(@c)=caller; $this->{CALLER}=[ @c ]; $this->{FLAGS}=0; $this->{POS}=0; $this->{BUF}=''; if ($type eq ASYNC) { $this->{FLAGS}|=$cs::IO::F_ASYNC; $type=shift; } if ($type eq FILE) { my($FILE)=shift; # align real fd with FILE eval "stat $FILE" && -f _ && sysseek($FILE,tell($FILE),0); if ($cs::Source::_UseIO) { my($fd)=fileno($FILE); if (! defined $fd) { warn "$::cmd: fileno($FILE): $!"; return undef; } ## warn "fd=$fd"; $this->{IO}=new_from_fd IO::Handle ($fd,"r"); } else { $this->{IO}=$FILE; } $this->{FLAGS}|=$cs::IO::F_NOCLOSE|$cs::IO::F_STICKYEOF; } elsif ($type eq TAIL) { my($path,$rewind)=@_; $rewind=0 if ! defined $rewind; my($io,$file)=_new_FILE($path,$rewind); return undef if ! defined $io; $this->{IO}=$io; $this->{POS}=($cs::Source::_UseIO ? $io->tell() : tell($io)); $this->{PATH}=$path; $this->{REALPATH}=$file; # debugging $type=FILE; } elsif ($type eq PATH) { my($path)=shift; if (! defined $path) { my(@c)=caller; die "\$path not set from [@c]"; } my($io,$file)=_new_FILE($path,1,@_); return undef if ! defined $io; $this->{IO}=$io; $path->{PATH}=$path; $path->{REALPATH}=$file; # debugging $type=FILE; $this->{FLAGS}|=$cs::IO::F_STICKYEOF; } elsif ($type eq PIPE) { my($pipefrom)=shift; if (ref $pipefrom) # assume subroutine ref { my($ds)=new cs::PipeDecode ($pipefrom,[ @_ ]); return undef if ! defined $ds; $this->{DS}=$ds; $type=Source; } else { my($pipeline)=" $pipefrom |"; my($io); if ($cs::Source::_UseIO) # shell command { $io=new IO::File; return undef if ! $io->open(" $pipefrom |"); } else { $io=cs::IO::mkHandle(); return undef if ! CORE::open($io," $pipefrom |"); } $this->{IO}=$io; $type=FILE; } } elsif ($type eq ARRAY) { $this->{ARRAY}=shift; } elsif ($type eq SCALAR) { my($scal)=shift; $this->{ARRAY}=[ ref($scal) ? $$scal : $scal ]; $type=ARRAY; } elsif ($type eq Source) { $this->{DS}=shift; } else { warn "$::cmd: Source::new: unknown type \"$type\""; my@c=caller;warn "\tfrom[@c]"; return undef; } $this->{TYPE}=$type; bless $this, $class; if ($cs::Source::_UseIO && exists $this->{IO} && ($this->{FLAGS}&$cs::IO::F_ASYNC)) { cs::IO::selAddSource($this); } $this; } sub _new_FILE($;$$) { my($path,$rewind,$complex)=@_; $rewind=0 if ! defined $rewind; $complex=0 if ! defined $complex; my($f,@f); ::need(cs::IO); ($f,@f)=($complex ? cs::IO::choose($path,$rewind ? undef : '') : $path); if (@f && ! $rewind) { warn "$::cmd: tried to tail \"$f\" [@f]"; return undef; } my($io)=cs::IO::openR($f,@f); if (defined $io) { if (! $rewind) { if (! ($cs::Source::_UseIO ? IO::Seekable::seek($io,0,2) : sysseek($io,0,2))) { warn "$::cmd: sysseek($io,0,2): $!"; } } return wantarray ? ($io,$f) : $io; } undef; } sub DESTROY { my($this)=@_; my($type)=$this->{TYPE}; if (length $this->{BUF}) # restore unprocessed data to downstream source { my($buf)=$this->_FromBuf(); if ($type eq Source) { $this->{DS}->_PushBuf($buf); } elsif ($type eq ARRAY) { unshift(@{$this->{ARRAY}},$buf); } } if (! $cs::Source::_UseIO && $type eq FILE && ! ($this->{FLAGS}&$cs::IO::F_NOCLOSE)) { close($this->{IO}) || warn "$::cmd: close($this->{IO}): $!"; } else { # warn "$::cmd: not try to close " # .cs::Hier::h2a($this) # .", made from [@{$this->{CALLER}}]" # if $type eq FILE; } } sub Handle # return filehandle name { my($this)=@_; exists $this->{IO} ? $this->{IO} : undef; } # skip forward in a source # returns the number of bytes skipped # or undef on error # NB: hitting EOF gets a short skip (including zero), not error # NB: an unspecified portion of the stream may have been read before an error # # works for any subclass provided BUF and TYPE are honoured sub Skip { my($this,$n)=@_; my($on)=$n; # $n gets used up local($_); # skip buffered data, if any if (length($_=$this->_FromBuf($n))) { $n-=length; # all from buffer return $on if $n == 0; } if ($this->Seekable()) # a seekable thing { my($to)=$this->Tell()+$n; if (! $this->Seek($to)) { warn "$::cmd: Skip($n): Seek($to): $!\n"; return undef; } } elsif ($this->{TYPE} eq Source) # pass skip command downstream in case it's got an efficient # Skip method { $on=$this->{DS}->Skip($n); } else { my($rn); # partial read size my($dummy); # we read in $_BUFSIZ chunks to avoid # malloc()ing obscene quantities of space # if someone asks to skip an immense void SKIP: while ($n > 0) { $rn=::min($n,$cs::Source::_BUFSIZ); $dummy=$this->Read($rn); return undef if ! defined $dummy; last SKIP if ! length $dummy; $n-=length($dummy); } $on-=$n; # how much not skipped } return $on; } # works for any subclass sub SkipTo { my($this,$pos)=@_; my($curr)=$this->Tell(); if ($pos < $curr) { warn "$::cmd: SkipTo($pos): can't skip backwards!"; } else { my($skipped)=$this->Skip($pos-$curr); return undef if ! defined $skipped; } $this->Tell(); } sub Tell { shift->{POS}; } sub Seekable { my($this)=shift; my($type)=$this->{TYPE}; $type eq FILE && $this->{IO}->stat() && -f _ || $type eq Source && $this->{DS}->Seekable(); } sub Seek { my($this,$where)=@_; warn "$::cmd: Seek(@_): where not defined: caller=".join('|',caller) if ! defined $where; if (! $this->Seekable()) { warn "$::cmd: Seek($where) on ".cs::Hier::h2a($this,0); return undef; } my($type)=$this->{TYPE}; my($retval); if ($type eq FILE) { my($io)=$this->{IO}; if (! ($retval=($cs::Source::_UseIO ? $io->seek($where,0) : sysseek($io,$where,0)))) { warn "$::cmd: seek($where,0): $!\n"; return undef; } } elsif ($type eq Source) { if (! ($retval=$this->{DS}->Seek($where))) { return undef; } } else { warn "$::cmd: don't know how to Seek($where) on ".cs::Hier::h2a($this,0); return undef; } $this->{POS}=$where; $this->{BUF}=''; return $retval; } sub PollIn { my($this,$size)=@_; $size=$this->ReadSize() if ! defined $size; my($n); local($_)=''; my($io)=$this->{IO}; $n=($cs::Source::_UseIO ? $io->sysread($_,$size) : sysread($io,$_,$size)); return undef if ! defined $n; warn "$::cmd: n ($n) != length (".length($_).")" if $n != length($_); $this->_AppendBuf($_) if length; length; } sub HasData { die "HasData(@_) when ! \$cs::Source::_UseIO" if ! $cs::Source::_UseIO; my($this)=@_; return 1 if length $this->{BUF}; my($type)=$this->{TYPE}; if ($type eq FILE) { my($io)=$this->{IO}; $io->can_read(0); } elsif ($type eq Source) { $this->{DS}->HasData(); } elsif ($type eq ARRAY) { @{$this->{ARRAY}}; } else { warn "$::cmd: no HasData() method for cs::Source of type \"$type\""; 0; } } sub ClearEOF { shift->{FLAGS}&=~$cs::IO::F_HADEOF; } sub Read { my($this,$size)=@_; $size=$this->ReadSize() if ! defined $size; my($type)=$this->{TYPE}; local($_); my($n); # check for buffered data if (length ($_=$this->_FromBuf($size))) # pending data { ## warn "returned buffered data [$_]\n"; return $_; } # nothing buffered, get data from the source # for some weird reason IO reseeks to 0 on EOF on SunOS, # hence this hack if ( ($this->{FLAGS}&($cs::IO::F_STICKYEOF|$cs::IO::F_HADEOF)) == ($cs::IO::F_STICKYEOF|$cs::IO::F_HADEOF) ) { return ''; } if ($type eq FILE) { my($io)=$this->{IO}; $n=($cs::Source::_UseIO ? $io->sysread($_,$size) : sysread($io,$_,$size)); if (! defined $n) { warn "$::cmd: Source::Read($this($io),$size): $!"; return undef; } ## warn "read $n bytes [$_]"; # clear error flag if we hit EOF if ($n == 0) { # warn "_UseIO=$cs::Source::_UseIO, io=[$io]"; # { my $o = tied $io; # if ($o) # { warn "$io is tied to ".cs::Hier::h2a($io,1); # } # } if ($cs::Source::_UseIO) { IO::Seekable::seek($io,0,1); } else { # sysseek($io,0,1); } $_=''; } } elsif ($type eq ARRAY) { my($a)=$this->{ARRAY}; return '' if ! @$a; # EOF $_=shift(@$a); if (length > $size) { $this->_PushBuf(substr($_,$[+$size)); substr($_,$[+$size)=''; } ## warn "post Read a=[@$a], BUF=[$this->{BUF}]"; } elsif ($type eq Source) { $_=$this->{DS}->Read($size); return undef if ! defined; } else { die "no cs::Source::Read method for type \"$type\""; } if (length) { $this->{POS}+=length; } else { $this->{FLAGS}|=$cs::IO::F_HADEOF; ## warn "============= HADEOF ==============="; ## warn "FLAGS=".$this->{FLAGS}; } $_; } sub NRead { my($this,$n)=@_; local($_); my($rd,$rn); while ($n > 0) { $rn=::min($n,$this->ReadSize()); $rd=$this->Read($rn); return undef if ! defined $rd; # error return $_ if ! length $rd; # EOF $_.=$rd; $n-=length $rd; } $_; } # suggest a size for the next read sub ReadSize { my($this)=@_; my($type)=$this->{TYPE}; # return pending size if (length $this->{BUF}) { return length $this->{BUF}; } my($size)=$cs::Source::_BUFSIZ; if ($type eq FILE) {} elsif ($type eq ARRAY) { if (@{$this->{ARRAY}}) { $size=length ${$this->{ARRAY}}[$[]; } } elsif ($type eq SCALAR) { $size=length ${$this->{SCALAR}}; } elsif ($type eq Source) { $size=$this->{DS}->ReadSize(); } $size; } sub _FromBuf($;$) { my($this,$n)=@_; $n=length $this->{BUF} if ! defined $n || $n > length($this->{BUF}); local($_)=substr($this->{BUF},$[,$n); substr($this->{BUF},$[,$n)=''; $this->{POS}+=length; ## warn "_FROMBUF=[$_]"; $_; } sub _PushBuf($$) { my($this,$data)=@_; ## {my(@c)=caller;warn "_PUSHBUF=($data) from [@c]";} substr($this->{BUF},$[,0)=$data; $this->{POS}-=length $data; } sub _AppendBuf($$) { my($this,$data)=@_; ## warn "_APPENDBUF=($data)"; $this->{BUF}.=$data; $this->{POS}-=length $data; } # get a line # return undef on error, '' on EOF, line-with-newline otherwise sub GetLine { my($this)=shift; my($i); local($_); # the line # check for line in the buffer if (($i=index($this->{BUF},"\n")) >= $[) { return $this->_FromBuf($i-$[+1); } # hmm - buffer has incomplete line # fetch entire buffer so that calls to read # return new data # we will push the unused stuff back when we're done my($buf)=$this->_FromBuf(); # loop getting data until we hit EOF or a newline while (defined ($_=$this->Read()) && length) { if (($i=index($_,"\n")) >= $[) # line terminator { $buf.=substr($_,$[,$i-$[+1); $this->_PushBuf(substr($_,$[+$i+1)); # save for later return $buf; } $buf.=$_; } # EOF or error # save unprocessed data $this->_PushBuf($buf); return '' if defined; # EOF undef; # error } sub GetAllLines { my($this)=shift; my(@a); local($_); while (defined ($_=$this->GetLine()) && length) { push(@a,$_); } wantarray ? @a : join('',@a); } sub GetContLine { my($this,$contfn)=@_; $contfn=sub { $_[0] =~ /^[ \t]/ } if ! defined $contfn; my($cline)=$this->GetLine(); return undef if ! defined($cline) || ! length($cline); local($_); CONT: while (defined ($_=$this->GetLine()) && length) { last CONT if ! &$contfn($_); $cline.=$_; } # push back unwanted line if (defined && length) { $this->_PushBuf($_); } $cline; } # collect whole file # (well, to first EOF mark) sub Get { my($this,$toget)=@_; local($_); my($got)=''; my($limited)=defined $toget; ## warn "Get(@_): limited=$limited, toget=$toget"; while ((! $limited || $toget > 0) && defined ($_=$this->Read($toget)) && length) { $got.=$_; $limited && ($toget-=length); ## warn "got[$_], length=".length($got); } ## warn "got=[$got]"; $got; } sub UnGet { my($this)=shift; for (reverse @_) { $this->_PushBuf($_); } } sub CopyTo { my($this,$sink,$max)=@_; my($copied)=0; local($_); COPY: while ((! defined $max || $max > 0) && defined ($_=$this->Read(defined $max ? $max : $this->ReadSize())) && length) { $copied+=length; if (! $sink->Put($_)) { warn "$::cmd: CopyTo: Put fails"; last COPY; } ## warn "copied [$_]"; } $copied; } # duplicate a source - consumes the original, so returns 2 copies sub Dup # (source) -> (copy1, copy2) { my($this)=@_; my($c1,$c2); $c1=$this->Get(); $c2=$c1; ((new cs::Source (SCALAR,\$c1)), (new cs::Source (SCALAR,\$c2)) ); } # link Dup, this consumes the source, so we return (FILE,copy) # in an array context; in a scalar context the source is lost sub DupToFILE { my($this)=@_; my($FILE)=cs::IO::tmpfile(); my($c1); if (wantarray) { my($c1); $c1=$this->Get(); print $FILE $c1; sysseek($FILE,0,0) || warn "$::cmd: rewind(tmpfile): $!"; return ($FILE,(new cs::Source (SCALAR,\$c1))); } ::need(cs::Sink); my($sink)=new cs::Sink (FILE,$FILE); $this->CopyTo($sink); sysseek($FILE,0,0) || warn "$::cmd: rewind(tmpfile): $!"; return $FILE; } 1; info2man-1.1/cs/GNUInfo/0040775000076400007640000000000007504401621015215 5ustar cjwatsoncjwatsoninfo2man-1.1/cs/GNUInfo/Node.pm0100644000076400007640000002054607332145625016452 0ustar cjwatsoncjwatson#!/usr/bin/perl # # cs::GNUInfocs::GNUInfo::Node: a node in a cs::GNUInfo object # - Cameron Simpson 5nov2000 # =head1 NAME cs::GNUInfo::Node - a node in a cs::GNUInfo object =head1 SYNOPSIS use cs::GNUInfo::Node; =head1 DESCRIPTION This module provides the node description used by the B object. =cut use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } use cs::Object; package cs::GNUInfo::Node; require Exporter; @cs::GNUInfo::Node::ISA=qw(cs::Object); sub dbg { &cs::GNUInfo::dbg; } =head1 GENERAL FUNCTIONS =over 4 =back =head1 OBJECT CREATION Preamble on creation methods. =over 4 =item new cs::GNUInfo::Node I, I Creates a new node of the specified I (B, B, etc) optionally named I. =cut sub new($$;$) { my($class,$type,$name)=@_; my $this={ TYPE => $type, TITLE => '', FIELDS => {}, DATA => [], HADNL => 1, INDENT => 0, INLIST => 0, SUBNODES => [], SUBNODENAMES => [], }; if (defined $name) { $this->{NAME}=$name; } bless $this, $class; } =back =head1 OBJECT METHODS =over 4 =item Type() Get the B of this node. =cut sub Type($) { shift->{TYPE}; } =item Name(I) Get or set the node name. =cut sub Name($;$) { my($this)=shift; $this->GetSet(NAME,@_); } =item Fields(I) if the optional parameter I is supplied, set values in the B hash from those in I. Returns a reference to the B hash. =cut sub Fields($;$) { my($this,$F)=@_; my $fields = $this->{FIELDS}; if (defined $F) { for (keys %$F) { $fields->{$_}=$F->{$_}; } } $fields; } =item Field(I,I) Set or get the B entry named I. =cut sub Field($$;$) { my($this,$name,$value)=@_; my $F = $this->Fields(); $F->{$name}=$value if defined $value; $F->{$name}; } =item Level(I) Set or get the B of this node, used to determine the heading level. =cut sub Level($;$) { my($this)=shift; $this->GetSet(LEVEL,@_); } =item SetLevels(I) Recursively mark this node and its subsidiaries with their depth. The I parameter is normally omitted, defaulting to B<1>. =cut sub SetLevels($;$) { my($this,$level)=@_; $level=1 if ! defined $level; local(%cs::GNUInfo::Node::_Active); $this->_SetLevels($level); } sub _SetLevels($$;$) { my($this,$level,$super)=@_; return if exists $cs::GNUInfo::Node::_Active{$this} && $cs::GNUInfo::Node::_Active{$this}; $cs::GNUInfo::Node::_Active{$this}=1; my $urlevel = $this->Level(); if (! defined $urlevel || $urlevel > $level) { $this->Level($level); $this->Super($super) if defined $super; } while (@{$this->{SUBNODENAMES}}) { my $name = shift(@{$this->{SUBNODENAMES}}); my $N = $this->ByName($name); if (defined $N) { $this->AddSubNode($N); } } for my $subN ($this->SubNodes()) { $subN->_SetLevels($level+1,$this); } delete $cs::GNUInfo::Node::_Active{$this}; } =item Info(I) Set or get the B of this node, a reference to the parent B object. =cut sub Info($;$) { my($this)=shift; $this->GetSet(INFO,@_); } =item ByName(I) Return the node named I by consulting the parent B object. =cut sub ByName($$) { my($this,$name)=@_; my $info = $this->Info(); warn "no INFO to look up \"$name\"" if ! defined $info; return undef if ! defined $info; $info->Node($name); } =item Title(I) Set or get the B<TITLE> of this node. =cut sub Title($;$) { my($this)=shift; $this->GetSet(TITLE,@_); } =item SubNodes() Return the array of subsidiary nodes. =cut sub SubNodes($) { @{shift->{SUBNODES}}; } =item AddSubNode(I<subnode>) Attach the specified I<subnode> as a child of this node. =cut sub AddSubNode($$) { my($this,$subnode)=@_; if (! grep($_ eq $subnode, $this->SubNodes())) { push(@{$this->{SUBNODES}}, $subnode); $subnode->Super($this); } } =item Super(I<parent>) Record the node I<parent> as the superior node of this one. =cut sub Super($;$) { my($this)=shift; $this->GetSet(SUPER,@_); } =item Data() Return a reference to the B<DATA> array. =cut sub Data($) { shift->{DATA}; } =item AddDatum(I<datum>) Push the I<datum> onto the end of the B<DATA> array. =cut sub AddDatum($$) { my($this,$datum)=@_; push(@{$this->Data()}, $datum); } =item Indent() Return the indent of the last line added to the node. =cut sub Indent($) { shift->{INDENT}; } =item HadNL() Return whether the last line added to the node was blank. =cut sub HadNL($) { shift->{HADNL}; } =item AddLine(I<line>,I<source>,I<filename>) Add the supplied line (from the B<cs::Source> I<source>, named I<filename>) to the node. If this is the first nonblank line and is a heading then set the title for the node and discard the line and add the first line after the heading. =cut sub AddLine($$$$) { my($this,$line,$s,$fname)=@_; chomp; s/\s+$//; my $data = $this->Data(); # skip leading blank lines while (!@$data && !length) { $_=$s->GetLine(); return if ! length; chomp; s/\s+$//; } # grab first line to see if it's a title if (! @$data) { my $possibletitle = $_; # grab second line to see if it underlines the first $_=$s->GetLine(); if (! length) # no next line - stash first line and get out { $this->AddDatum($possibletitle); return; } chomp; s/\s+$//; if (length == length($possibletitle) && $_ eq substr($_,$[,1) x length ) # underlined title found { $this->Title($possibletitle); } else # not a title I guess { $this->AddDatum($possibletitle); $this->AddDatum($_); } $_=$s->GetLine(); return if ! length; } chomp; s/\s+$//; $_=::detab($_); # watch indent changes # this is only here to do some really gross intuition of itemised # lists from indent changes if (/^\s+/) { my $nindent = length($&); $_=$'; if ($nindent == 4 && ! $this->{HADNL} && $this->{INDENT} == 0) { } $this->{INDENT}=$nindent if length; # blank lines don't change indent } if (/^\*\s+([^:]+)::\s*(.*)/ # * hook:: comment || /^\*\s+([^:]+):\s+(\S[^\.]*)\s*/ # * hook: node, comment ) # note subsidary nodes { } # save line $this->AddDatum($_); $this->{HADNL}=(length == 0); } =item Pod2s(I<sink>) Transcribe this node and its subsidiaries to the B<cs::Sink> I<sink>. =cut sub Pod2s($$) { my($this,$s)=@_; my $neednl=0; my $title = $this->Title(); dbg("transcribe node \"$title\""); my $name = $this->Name(); if (defined $name) { if (exists $cs::GNUInfo::Node::SeenNode{$name}) { ## dbg("already seen \"$name\""); return; } $cs::GNUInfo::Node::SeenNode{$name}=1; if (! length $title) { $title=$name; $this->Title($title); } } if (length $title) { my $level = $this->Level(); $level=2 if ! defined $level; if ($level == 1 || $level == 2) { $s->Put("=head$level $title\n\n"); } else { $s->Put("\nB<$title>\n\n"); } } my $data = $this->Data(); ## dbg("NO DATA!") if ! @$data; for my $D (@$data) { if (! ref $D) # plain text { $D =~ s/[<>]/$& eq '<' ? 'E<lt>' : 'E<gt>'/eg; # * hook:: comment if ($D =~ /^\*\s+([^:]+)::\s*(.*)/) { if (length $2) { $D="$2: see L<\"$1\">\n"; } else { $D="See also L<\"$1\">\n"; } } # * hook: node, comment elsif ($D =~ /^\*\s+([^:]+):\s+(\S[^\.]*)\s*/) { $D="$1: see L<\"$2\">"; $D.=", $'" if length $'; $D.="\n"; } else # plain text { $D =~ s/\*note\s+([^:\s][^:]*)::/see L<"$1">/ig; } $D =~ s/`([^`']+)'/`B<$1>'/g; ## dbg("PUT $D"); $s->Put($D); $s->Put("\n"); $neednl=length($D); } else # object { my($dtype,@detc)=@$D; if ($dtype eq MENU) { dbg("MENU: no data!") if ! @{$detc[0]}; for my $M (@{$detc[0]}) { if (! ref $M) { $s->Put("$M\n"); } else { $s->Put("L<$M->{HOOK}|\"$M->{NODE}\">\t$M->{COMMENT}\n"); } } } else { warn "$::cmd: Pod2s(): unknown FILE datum type \"$dtype\" in block"; } } } if ($neednl) { $s->Put("\n"); } for my $subN ($this->SubNodes($name)) { $subN->Pod2s($s); } } =back =head1 SEE ALSO cs::GNUInfo(3) =head1 AUTHOR Cameron Simpson E<lt>cs@zip.com.auE<gt> =cut 1; ����������������������������������������������������������������������������������������������������������������������������������������������������������info2man-1.1/cs/Object.pm���������������������������������������������������������������������������0100644�0000764�0000764�00000004155�07176151461�015525� 0����������������������������������������������������������������������������������������������������ustar �cjwatson������������������������cjwatson���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/perl # # Core object. Really just a dummy DESTROY so we can always call # SUPER::DESTROY. # - Cameron Simpson <cs@zip.com.au> 21jul97 # =head1 NAME cs::Object - root class for objects =head1 SYNOPSIS use cs::Object; @ISA=(cs::Object); =head1 DESCRIPTION The B<cs::Object> module provided a few common methods for most objects. =cut use strict qw(vars); BEGIN { use cs::DEBUG; cs::DEBUG::using(__FILE__); } package cs::Object; @cs::Object::ISA=(); =head1 GENERAL FUNCTIONS =over 4 =item reTIEHASH(I<preserve>,I<hashref>,I<class>,I<tiehashargs>...) Tie the hash referenced by I<hashref> to the specified I<class>, passing the I<tiehashargs> to the B<tie> call. If the optional parameter I<preserve> is B<1>, store the original contents of the hash in the tied object. =cut # ([preserve,]hashref,class[,TIEHASH-args]) sub reTIEHASH { {my(@c)=caller;warn "reTIEHASH(@_) from [@c]";} my($preserve)=($_[0] =~ /^[01]$/ ? shift(@_) : 1 ); my($phash,$impl)=(shift,shift); my %tmp; if ($preserve) { # copy the contents for my $key (keys %$phash) { $tmp{$key}=$phash->{$key}; } } tie(%$phash,$impl,@_) || die "tie($phash,$impl,@_) fails"; if (! defined $preserve) # ignore {} elsif ($preserve) # overwrite { # put the contents back for my $key (keys %tmp) { $phash->{$key}=$tmp{$key}; } } else # supply if missing - a bit dubious { for my $key (keys %tmp) { $phash->{$key}=$tmp{$key} if ! exists $phash->{$key}; } } } =back =cut sub DESTROY {} =head1 OBJECT METHODS =over 4 =item GetSet(I<field>,I<value>) If the optional parameter I<value> is supplied, set the specified I<filed> of the object to I<value>. Otherwise return the current value of I<field> or B<undef> if it does not exist. =cut sub GetSet($$;$) { my($this,$field,$value)=@_; if (defined $value) { $this->{$field}=$value; } else { if (! exists $this->{$field}) { ## my@c=caller;warn "no $field in $this\n\tfrom [@c]\n\t"; return undef; } $this->{$field}; } } =back =head1 AUTHOR Cameron Simpson <cs@zip.com.au> 21jul1997 =cut 1; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������info2man-1.1/cs/DEBUG.pm����������������������������������������������������������������������������0100644�0000764�0000764�00000002453�07115655161�015143� 0����������������������������������������������������������������������������������������������������ustar �cjwatson������������������������cjwatson���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/perl use strict qw(vars); package cs::DEBUG; %cs::DEBUG::Trace=( USE => defined($ENV{'csPLDEBUG'}) && length($ENV{'csPLDEBUG'}) > 0, EXPORT => 1 ); { package main; if (defined $ENV{'csPLDEBUG'}) { my $dbg=join(';', map('warn "DEBUG: debugging package '.$_.'\n");$cs::'.$_.'::DEBUG=1', grep(/^[a-z_][:\w]*$/i,split(/,+/,$ENV{'csPLDEBUG'})))); eval $dbg; warn "cs::DEBUG: $@ in [$dbg]" if $@; } } # $Exporter::Verbose=$Trace{EXPORT}; sub using { my(@c)=caller(1); ## pstack(); print STDERR "$0: using @_ from [@c]\n" if $cs::DEBUG::Trace{USE}; } sub err { my($err,$arg)=@_; cs::Upd::err($err); if (defined $arg) { warn "arg = ".cs::Hier::h2a($arg,1)."\n"; pstack(); } } sub pstack { my(@s)=cstack(1); my($p,$f,$l,$sub); for (@s) { ($p,$f,$l,$sub)=@$_; warn "$f:$l: ${p}::$sub\n"; } } sub cstack { my($i)=shift; my(@s,@c); $i=0 unless defined $i; CALL: while (@c=caller($i)) { push(@s,[ @c ]); $i++; } @s; } sub phash { my($h)=@_; my(@c)=caller; warn "phash($h) from [@c]\n"; for my $hkey (sort keys %$h) { my($val)=$h->{$hkey}; warn "\t$hkey=$val\n"; if (ref $val && ::reftype($val) eq ARRAY) { for my $i (0..$#$val) { warn "\t$hkey\[$i]=$val->[$i]\n"; } } } } 1; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������info2man-1.1/0README.txt����������������������������������������������������������������������������0100664�0000764�0000764�00000503660�07504410350�015127� 0����������������������������������������������������������������������������������������������������ustar �cjwatson������������������������cjwatson���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������This file is an autogenerated list of the header comments of all the scripts. Overview documentation for some may be found here: http://www.zip.com.au/~cs/css/ and manual entries in HTML format here: http://www.zipworld.com.au/~cs/man/ Installing my scripts: Unpack the tarball: http://www.zip.com.au/~cs/css/scripts.tar.gz into a suitable directory (eg "~/scripts-cs", which I will assume for the sake of example below). Add the full pathname for that directory to the END of your $PATH. Also add the full path for the directory ~/scripts-cs/synonyms. The Perl modules are in the directory ~/scripts-cs/cs, so add ~/scripts-cs to your $PERL5LIB varaible, or make a symlink named "cs" from your generic perl library directory to that subdir. The aim here is that "use cs::blah" will find the module ~/scripts-cs/cs/blah.pm. Several of the scripts expect the following shell environment variables: $HOST Your machine's short name. $HOSTNAME Your machine's fully qualified domain name. $ARCH Your architecure, in the form vendor.cpu.os, eg sun.sparc.solaris or sgi.mips.irix. $SYSTEMID A name for your machines administrative domain (eg: I use "cisra" for my workplace: CISRA, "home" for home and "zip" for my ISP: zip.com.au). $USER Your login name. $SITENAME Your email domain (eg zip.com.au for me). $EMAIL Your email address (just "who@where", no "<>"s); normally $USER@$SITENAME. There are some others, but those cover the common stuff. Licence: You're free to use, modify and redistribute these scripts provided that: - you leave my code marked as mine and your modifications (if any) marked as yours - you make recipients aware that the scripts can be obtained for free from my own web page Warrantee: None whatsoever! These scripts work for me, but any of them may have bugs or be arbitrarily dependent on my own login environment. While I try to make most of them usable by others (and am happy to hear suggestions or bug reports), they're for my use and may well not meet your needs. But feel free to hack them to meet your needs. - Cameron Simpson <cs@zip.com.au> http://www.zip.com.au/~cs/ +: #!/bin/sh +: # +: # Read a mail folder with mutt. +: # - Cameron Simpson <cs@zip.com.au> +: # 1970: #!/bin/sh 1d: #!/bin/sh 2alert: #!/bin/sh 2ps: #!/bin/sh 2ps: # 2ps: # Convert input to PostScript. 2ps: # Expects PostScript's first line to start with 2ps: # %!PS-Adobe 2ps: # PDF to start with 2ps: # %PDF 2ps: # and plain text to start with something else. 2ps: # - Cameron Simpson <cs@zip.com.au> 12dec96 2ps: # 2tek: #!/bin/sh 2vt: #!/bin/sh 2xpm: #!/bin/sh 2xpm: # 2xpm: # Create a temporary xpm file, run a command with it as argument, 2xpm: # remove the file. Adapted from setrxvtbg. 2xpm: # - Cameron Simpson <cs@zip.com.au> 20nov2000 2xpm: # 48toxbm: #!/usr/bin/perl 48toxbm: # 48toxbm: # Read a 48x48x1 face file and write an xbm bitmap. 48toxbm: # - Cameron Simpson <cs@zip.com.au>, 15jul94 48toxbm: # 755: #!/bin/sh :n: #!/bin/sh @: #!/bin/sh @: # @: # Open fresh shell on target machine in new window. @: # - Cameron Simpson <cs@zip.com.au> 23oct2001 @: # Crp: #!/bin/sh Cvsedit: #!/bin/sh HUP: #!/bin/sh L: #!/bin/sh Man: #!/bin/sh Mkdir: #!/bin/sh Mykefile: ## :include dir2html R: #!/bin/sh SZ: #!/bin/sh SZ: # SZ: # ps sorted of process size or resident size. SZ: # - Cameron Simpson <cs@zip.com.au> SZ: # a2p: #!/usr/bin/perl a2p: # a2p: # Yet another ASCII to PostScript. a2p: # - Cameron Simpson <cs@zip.com.au> 10may97 a2p: # abpm: #!/bin/sh abpm: # abpm: # absurl: #!/usr/bin/perl absurl: # absurl: # Read URLs, convert to absolute ones w.r.t to supplied base. absurl: # - Cameron Simpson, cs@zip.com.au, 24aug97 absurl: # absurl: # -h to restrict results to origin page's host. - cameron, 17apr98 absurl: # acon: #!/bin/sh acro: #!/bin/sh acro: # acro: # Look up acronyms. - Cameron Simpson <cs@zip.com.au> acro: # addlinkpage: #!/bin/sh addlinkpage: # addlinkpage: # Add a link page URL to a list of link pages. addlinkpage: # - Cameron Simpson <cs@zip.com.au> 04aug2000 addlinkpage: # addtail: #!/bin/sh addtail: # addtail: # Add a log to the things being tailed. addtail: # - Cameron Simpson <cs@zip.com.au> 25may1996 addtail: # after: #!/bin/sh after: # after: # Run a command later. after: # - Cameron Simpson <cs@zip.com.au> 13sep2000 after: # aftp: #!/bin/sh aftp: # aftp: # Anonymous ftp to a host. aftp: # - Cameron Simpson, cs@zip.com.au aftp: # aka: #!/usr/bin/perl aka: # aka: # Become user; bypass shell. - Cameron Simpson, 02may94 aka: # aka: # Bug: doesn't fiddle with secondary groups at all. aka: # alert: #!/bin/sh alertlog: #!/bin/sh alog: #!/bin/sh alog: # alog: # Run command asynchronously with output to a logfile. alog: # - Cameron Simpson <cs@zip.com.au> 09feb2002 alog: # amex: #!/bin/sh amex: # AMEX Online Services. - Cameron Simpson <cs@zip.com.au> 03may2002 announce-email: #!/bin/sh announce-email: # announce-email: # Read an email message from stdin, announce to alert log. announce-email: # - Cameron Simpson <cs@zip.com.au> 28mar2002 announce-email: # announceddtsemail: #!/bin/sh announceddtsemail: # announceddtsemail: # Announce the arrival of a new DDTS request. announceddtsemail: # - Cameron Simpson <cs@zip.com.au> 05dec2001 announceddtsemail: # # anytopnm - attempt to convert an unknown type of image file to a P?M file. # append - append data to a file # apphelper - a generic wrapper for email attachments or web browser file helpers, offering both save and view choices apsum: #!/bin/sh aptally: #!/usr/bin/perl aptally: # aptally: # Walk Apache cache and report stats in the form aptally: # total class aptally: # where the class depends on the type of data: aptally: # HOST hostname of URL aptally: # TYPE content-type aptally: # apupd: #!/bin/sh apupd: # apupd: # Notice changes in tallies. apupd: # - Cameron Simpson <cs@zip.com.au> apupd: # aputmp2a: #!/usr/bin/perl aputmp2a: # aputmp2a: # Unpacker for utmp/wtmp records on Apollos. aputmp2a: # archive: #!/bin/sh archive: # archive: # Make a gnutar archive of the specified directories in an archive archive: # (default stdout, known as -), and record an index of the files as archive: # md5 size path archive: # in the file archive.toc. archive: # - Cameron Simpson <cs@zip.com.au> 24oct98 archive: # archlog: #!/bin/sh archlog: # archlog: # Archive a log file in a separate archival area. archlog: # - Cameron Simpson <cs@zip.com.au> 19nov97 archlog: # archuser: #!/bin/sh archuser: # archuser: # Archive a user directory. archuser: # - Cameron Simpson <cs@zip.com.au> 21feb2001 archuser: # arg0: #!/bin/sh arg0: # arg0: # No-op arg0 for bootstrap stage. arp2ethers: #!/usr/bin/perl arp2ethers: # arp2ethers: # Read arp -a output and emit /etc/ethers format. arp2ethers: # - Cameron Simpson <cs@zip.com.au> 01sep95 arp2ethers: # article: #!/bin/sh article: # ask: #!/bin/sh askcisco: #!/bin/sh askcisco: # askcisco: # Send a single command to a switch, fetch reply. askcisco: # - Cameron Simpson <cs@zip.com.au> 27jan99 askcisco: # au: #!/bin/sh aulist: #!/bin/sh aulist: # aulist: # List audio files for selection. aulist: # - Cameron Simpson <cs@zip.com.au> 01jun2002 aulist: # await: #!/bin/sh await: # await: # Await some condition, then exit. await: # - Cameron Simpson, 05nov93 await: # babel: #!/bin/sh babel: # babel: # Use the babelfish translator. babel: # - Cameron Simpson <cs@zip.com.au> 19nov98 babel: # backupmysql: #!/bin/sh backupmysql: # backupmysql: # Dump a mysql database. backupmysql: # - Cameron Simpson <cs@zip.com.au> 08jun2001 backupmysql: # base64: #!/usr/bin/perl base64: # base64: # Encode data in base64 format.. base64: # Very quick'n'dirty. Should really stream for large input. base64: # - Cameron Simpson <cs@zip.com.au> 27aug2001 base64: # bfilt: #!/bin/sh bgdirs: #!/bin/sh bgfg: #!/bin/sh bgfg: # bgfg: # Dispatch a contrast bug report. bgfg: # - Cameron Simpson <cs@zip.com.au> bgfg: # bglist: #!/bin/sh bglist: # bglist: # Offer a list of background images. bglist: # - Cameron Simpson <cs@zip.com.au> 10may1999 bglist: # bgproc: #!/bin/sh bgproc: # bgproc: # Background a command. bgproc: # Copy output to a log. bgproc: # Record the pid in a file. bgproc: # NoHUP it. bgproc: # - Cameron Simpson <cs@zip.com.au> 25aug99 bgproc: # bgprocmail: #!/bin/sh bgprocmail: # bgprocmail: # Copy input, run procmail in the background. bgprocmail: # - Cameron Simpson <cs@zip.com.au> 05may2002 bgprocmail: # bgrm: #!/bin/sh bgrm: # bgrm: # For each target, move aside and issue an async rm. bgrm: # - Cameron Simpson <cs@zip.com.au> 19jul98 bgrm: # bgssh: #!/bin/sh bgssh: # bgssh: # Wrapper to background ssh and prefix the output. bgssh: # - Cameron Simpson <cs@zip.com.au> 24may99 bgssh: # bgstdin: #!/bin/sh bgstdin: # bgstdin: # Background command but keep attached to stdin. bgstdin: # - Cameron Simpson <cs@zip.com.au> 12sep2000 bgstdin: # bgstop: #!/bin/sh bgstop: # bgstop: # Kill a job started with bgproc. bgstop: # - Cameron Simpson <cs@zip.com.au> 25aug99 bgstop: # bgxrefmailitem: #!/bin/sh bib: #!/bin/sh bib: # bib: # Consult bibliographic database, print results. bib: # - Cameron Simpson, 30nov93 bib: # binlink: #!/bin/sh binlink: # binlink: # Link something into my bins, usually a script. binlink: # Obsolete these days; I'm back to using a long PATH binlink: # instead of doing it The Plan 9 Way. binlink: # - Cameron Simpson <cs@zip.com.au> binlink: # bm: #!/usr/bin/perl bm: # bm: # Bookmark something. bm: # - Cameron Simpson <cs@zip.com.au> 30sep97 bm: # bnm: #!/bin/sh bounce: #!/bin/sh bounce: # bounce: # Remove addresses from a mailing list. bounce: # - Cameron Simpson <cs@zip.com.au> 12apr2000 bounce: # # bsed - batch edit with sed btdd: #!/bin/sh btdd: # btdd: # Budtool compatible dd command. btdd: # - Cameron Simpson <cs@zip.com.au> 12nov99 btdd: # btinfo: #!/usr/bin/perl btinfo: # btinfo: # Get info from the budtool system. btinfo: # - Cameron Simpson <cs@zip.com.au> 07nov2000 btinfo: # btread: #!/bin/sh btread: # btread: # Read a file from a tape written by budtool. btread: # This script primarily exists to document the magic blocksize. btread: # - Cameron Simpson <cs@zip.com.au> 27jul98 btread: # btvls: #!/bin/sh # buff - backup file finder bundle: #!/bin/sh bundle: # bundle: # Bundle up a directory as a compressed tar file. bundle: # - Cameron Simpson <cs@zip.com.au> bundle: # bx: #!/bin/sh bz2: #!/bin/sh c: #!/bin/sh c2man: #!/bin/sh c2man: # c2man: # Extract manual entries from C source files. c2man: # - Cameron Simpson, January 1992 c2man: # c2man: # Added -h option. - Cameron Simpson, September 1992 c2man: # calpasswd: #!/bin/sh calpasswd: # calpasswd: # Set password for calendar user. calpasswd: # - Cameron Simpson <cs@zip.com.au> 05jan98 calpasswd: # cancel: #!/bin/sh cancel: # catmaildir: #!/bin/sh catmaildir: # catmaildir: # Output all the numerically named files in the named directories catmaildir: # in UNIX mail file format. catmaildir: # - Cameron Simpson <cs@zip.com.au> 27mar2000 catmaildir: # cats: #!/bin/sh cats2procmailrc - generate a procmail recipe from my mail categories file cc_x11: #!/bin/sh cccs: #!/bin/sh cccs: # cccs: # Simple way to invoke cc for my code. cccs: # - Cameron Simpson <cs@zip.com.au> cccs: # cddiscinfo: #!/usr/bin/perl cddiscinfo: # cddiscinfo: # Extract discid and track info from a CD as a preliminary to cddiscinfo: # constructing a FreeDB CDDB entry. Used by cdsubmit. cddiscinfo: # - Cameron Simpson <cs@zip.com.au> 14mar2001 cddiscinfo: # cdrip: #!/bin/sh cdrip: # cdrip: # Yet another audio CD ripper. Easiest way to learn the tools :-) cdrip: # Like mkcd and mkiso, this is meant to be a no brainer command line. cdrip: # - Cameron Simpson <cs@zip.com.au> 12mar2001 cdrip: # cdrip: # Add MP3 mode, basicly for my brother. -cameron 25aug2001 cdrip: # cdsubmit: #!/bin/sh cdsubmit: # cdsubmit: # Submit a CD description to the FreeDB CD Database. cdsubmit: # Also write a cache entry into ~/.cddb for use by programs. cdsubmit: # - Cameron Simpson <cs@zip.com.au> 25aug2001 cdsubmit: # cdtoc: #!/usr/bin/perl cdtoc: # cdtoc: # Emit a table of contents for a CD. cdtoc: # - Cameron Simpson <cs@zip.com.au> 14mar2001 cdtoc: # ce: #!/bin/sh cfall: #!/bin/sh cgid: #!/usr/bin/perl cgid: # cgid: # Use the specified perl file and then serve HTTP requests. cgid: # Call doCGI($cgiObj) for each request. cgid: # - Cameron Simpson <cs@zip.com.au> 30dec97 cgid: # cgihtnisauth: #!/bin/sh cgihtnisauth: # cgihtnisauth: # Script to require UNIX NIS login for a CGI script. cgihtnisauth: # - Cameron Simpson <cs@zip.com.au> 12feb2001 cgihtnisauth: # cgihtnisauth: # Exit status: 0 for a match, with userid on stdout. cgihtnisauth: # 1 for failure, with 401 response on stdout. cgihtnisauth: # cgihtnisauth: # Use in CGI sh script: cgihtnisauth: # userid=`cgihtnisauth` || { echo "$userid"; exit 0; } cgihtnisauth: # cgihtnisauth: # Use in CGI perl script: cgihtnisauth: # $userid=`cgihtnisauth`; cgihtnisauth: # if ($? != 0) { print $userid; exit 0; } cgihtnisauth: # chomp($userid); cgihtnisauth: # cgihtnisauth: # That spits out the 401 and exits cleanly on auth failure, cgihtnisauth: # and continues with the login name in $userid on auth success. cgihtnisauth: # cgiwrap: #!/bin/sh cgiwrap: # cgiwrap: # Wrapper for CGI scripts which sets environment and captures and cgiwrap: # reports errors. cgiwrap: # For any perl CGI, mv the real .cgi to .cgi-pl and link this script to cgiwrap: # the old .cgi name. cgiwrap: # For any shell CGI, mv the real .cgi to .cgi-sh and link this script to cgiwrap: # the old .cgi name. cgiwrap: # - Cameron Simpson <cs@zip.com.au> 03mar1999 cgiwrap: # cgiwrap: # Make single wrapper for pl and sh. - cameron 12feb2001 cgiwrap: # cgiwrap: # snapshot errors and attach to output bottom chat: #!/bin/sh check: #!/bin/sh check: # check: # Random system checks. check: # checkzipmail: #!/bin/sh checkzipmail: # checkzipmail: # Check my currently unforwarded email. checkzipmail: # - Cameron Simpson <cs@zip.com.au> 14dec2000 checkzipmail: # chfiles: #!/bin/sh chfiles: # chfiles: # Return a list of all *.[ch] files. chfiles: # It's surprising how often I want this. chfiles: # - Cameron Simpson <cs@zip.com.au> 04jul2000 chfiles: # chkaliases: #!/bin/sh chkaliases: # chkaliases: # Check for undeliverable addresses in system aliases. chkaliases: # - Cameron Simpson <cs@zip.com.au> 26jul95 chkaliases: # chkbuddb: #!/usr/bin/perl chkbuddb: # chkbuddb: # Sanity check the backup database records. chkbuddb: # - Cameron Simpson <cs@zip.com.au> 13aug99 chkbuddb: # chkcal: #!/usr/bin/perl chkcal: # chkcal: # Chkcal - check calendar against user db. chkcal: # - Cameron Simpson <cs@zip.com.au> chkcal: # chkcase: #!/usr/bin/perl chkcase: # chkcase: # Look for case conflicts in directories. chkcase: # - Cameron Simpson <cs@zip.com.au> 24oct98 chkcase: # chkexpiry: #!/usr/bin/perl chkexpiry: # chkexpiry: # Report user's days until expiry. chkexpiry: # - Cameron Simpson <cs@zip.com.au> 12apr2000 chkexpiry: # chkexpiry: # Arg list. Fix rounding bug. - cameron 04may2000 chkexpiry: # chkfiles: #!/usr/bin/perl chkfiles: # chkfiles: # Examine a list of files to see which have changed. chkfiles: # - Cameron Simpson <cs@zip.com.au> 24aug96 chkfiles: # chkhdb: #!/usr/bin/perl chkhdb: # chkhdb: # Sanity check the host database. chkhdb: # - Cameron Simpson <cs@zip.com.au> 13apr2001 chkhdb: # chkhomesymlinks: #!/usr/bin/perl chkhomesymlinks: # chkhomesymlinks: # Find symbolic links in the specified directory chkhomesymlinks: # chkhostethers: #!/usr/bin/perl chkhostethers: # chkhostethers: # Check for duplicated ethaddrs in host table. chkhostethers: # - Cameron Simpson <cs@zip.com.au> 21oct98 chkhostethers: # chkmspool: #!/bin/sh chkmspool: # chkmspool: # Locate mail files not starting with "From ". Used after a crash. chkmspool: # - Cameron Simpson <cs@zip.com.au> 15jan98 chkmspool: # chknsr: #!/bin/sh chknsr: # chknsr: # Check that Mick Doohan^W^W nsr (Legato Networker) is installed. chknsr: # - Cameron Simpson <cs@zip.com.au> 26sep2000 chknsr: # chkotpad: #!/usr/bin/perl chkotpad: # chkotpad: # Check a pad file for matching its name. chkotpad: # - Cameron Simpson <cs@zip.com.au> 24jul2000 chkotpad: # chkpatching: #!/usr/bin/perl chkpatching: # chkpcshares: #!/bin/sh chkpcshares: # chkpcshares: # Check the pc share list for changes. chkpcshares: # Since we're more interested in new shares which may not be backed up chkpcshares: # we preserve the shares from unpingable hosts. chkpcshares: # - Cameron Simpson <cs@zip.com.au> 04nov98 chkpcshares: # chkslinks: #!/usr/bin/perl chkslinks: # chkslinks: # Courtesy of mcook@fendahl.dev.cdx.mot.com (Michael Cook). chkslinks: # chkstatus: #!/bin/sh chkstatus: # chkstatus: # Perform a variety of checks on services and return single line result chkstatus: # reports on stdout. This is the tail end of a general purpose monitoring chkstatus: # scheme which loops over a set of servers, sshing in with a phraseless key chkstatus: # which always runs this script. chkstatus: # See also: chkstatus2html chkstatus: # - Cameron Simpson <cs@zip.com.au> 24may2001 chkstatus: # chkstatus: # Config file format: chkstatus: # tag tcpport portnum chkstatus: # tag udpport portnum chkstatus: # tag dfk pathname freekB chkstatus: # tag ps regexp chkstatus: # tag load busy high chkstatus: # tag mailq chkstatus: # Blank lines and # comments also supported. chkstatus: # chkstatus: # Output is lines of the form: chkstatus: # tag {UP|DOWN|OK|LOW|ZERO|FULL|EMPTY|UNFLUSHED} [info...] chkstatus: # chkstatus2html: #!/bin/sh chkstatus2html: # chkstatus2html: # Write status information about hosts out as an HTML TABLE. chkstatus2html: # See the chkstatus command. chkstatus2html: # - Cameron Simpson <cs@zip.com.au> 24may2001 chkstatus2html: # chkwiring: #!/usr/bin/perl chkwiring: # chkwiring: # Sanity check the wiring db, both internally and against the chkwiring: # status reported by the switches. chkwiring: # - Cameron Simpson <cs@zip.com.au> 28jan99 chkwiring: # chserver: #!/usr/bin/perl chserver: # chserver: # Usage: chserver [-a] oldserver newserver machines... chserver: # chserver: # Change links in /server on the specified machines. chserver: # Oldserver and newserver are machine names, possibly with leading slashes. chserver: # Each machine named is either chserver: # - A machine name, possibly with leading slashes. chserver: # - A directory name. This is distinguished by having chserver: # further components after the machine name. chserver: # chserver: # Machine names map to the directory //machine/server. chserver: # The directories thus specified are walked, and all symlinks pointing chserver: # directly at //oldserver are removed, and new ones pointing at //newserver chserver: # are made. If the -a flag is supplied, symlinks of the form //oldserver/... chserver: # are also suitably manipulated. chserver: # chserver: # For example, to point all the blue machines at silver one might say: chserver: # chserver gold silver //blue*/server chserver: # ciscoportinfo: #!/bin/sh ciscoportinfo: # ciscoportinfo: # Retrieve information about a switch port. ciscoportinfo: # - Cameron Simpson <cs@zip.com.au> 19aug99 ciscoportinfo: # ciscoportlist: #!/bin/sh clean_mailman_lists: #!/bin/sh clean_mailman_lists: # clean_mailman_lists: # Remove expired users from the mailman lists. clean_mailman_lists: # - Cameron Simpson <cs@zip.com.au> 01nov2001 clean_mailman_lists: # cleanlocks: #!/bin/sh cleanlocks: # cleanlocks: # Remove obsolete lock directories for this host. cleanlocks: # - Cameron Simpson <cs@zip.com.au> 14jun2002 cleanlocks: # cleansubj: #!/bin/sed -f cleansubj: # cleansubj: # Tidy up Subject: lines. cleansubj: # Strip multiple Re: stuff and [list] tags. cleansubj: # - Cameron Simpson <cs@zip.com.au> 14feb2002 cleansubj: # clip: #!/usr/bin/perl clip: # clip: # Usage: clip [-r] [-f] [width] [--] [files...] clip: # clippath: #!/bin/sh cmd-x: #!/bin/sh cmdlog: #!/bin/sh cmdlog: # cmdlog: # Run command with output redirected to self-named log file. cmdlog: # - Cameron Simpson <cs@zip.com.au> 15dec2000 cmdlog: # collate: #!/usr/bin/perl colour_echo: #!/bin/sh colour_highlight: #!/bin/sh colour_highlight: # colour_highlight: # Highlight content matching sed regexps with a colour. colour_highlight: # - Cameron Simpson <cs@zip.com.au> 22sep99 colour_highlight: # colourise: #!/bin/sh colourise: # colourise: # Perform a typical colourisation. colourise: # - Cameron Simpson <cs@zip.com.au> 06may99 colourise: # colsum: #!/bin/sh colsum: # colsum: # Sum numbered columns on data. colsum: # - Cameron Simpson <cs@zip.com.au> 19jan97 colsum: # con: #!/bin/sh con: # con: # Run a command with its output attached to the console. con: # - Cameron Simpson <cs@zip.com.au> con: # configcs: #!/bin/sh consolelog: #!/bin/sh consolelog: # copylog: #!/usr/bin/perl copylog: # copylog: # Tail -f of various inlogspecs, copying the results to the log copylog: # specified by a logmap logspec. copylog: # - Cameron Simpson <cs@zip.com.au>, 27jul94 copylog: # cores: #!/bin/sh count: #!/bin/sh cpdb: #!/usr/bin/perl cpdb: # cpdb: # - Cameron Simpson <cs@zip.com.au> cpdb: # cpdir: #!/bin/sh cpdir: # cpdir: # Copy a directory tree - refuse if target exists as safety measure. cpdir: # Faster, safer, more accurate and more informative than "cp -rp". cpdir: # - Cameron Simpson <cs@zip.com.au> cpdir: # cpmod: #!/usr/bin/perl cpmod: # cpmod: # Copy file modes from one file to another. cpmod: # - Cameron Simpson <cs@zip.com.au> 05jan99 cpmod: # cppdefs: #!/bin/sh cshook: #!/bin/sh csmkproto: #!/usr/bin/perl csmkproto: # csmkproto: # Extract prototypes from ANSI C source. csmkproto: # Believes stringly in my formatting style. csmkproto: # - Cameron Simpson, 27sep93 csmkproto: # csmkproto: # BUGS: The CPP synchronicity goes to hell if the static and extern stuff go to csmkproto: # the same place. csmkproto: # csml2html: #!/usr/bin/perl csml2html: # csproto: #!/usr/bin/perl csproto: # csproto: # Convert KnR C code of the form csproto: # type csproto: # fn(a,b) csproto: # t1 a; csproto: # t2 b; csproto: # { csproto: # into csproto: # type csproto: # fn( t1 a, csproto: # t2 b) csproto: # { csproto: # csproto: # Cameron Simpson, 10sep93 csproto: # csroff: #!/usr/bin/perl csroff: # csroff: # Convert troff-like input to real troff or HGML. csroff: # - Cameron Simpson, 01jan93 csroff: # cvscommit: #!/bin/sh cvscommit: # cvscommit: # Commit changes, using commit-editor to make the log more helpful to its author. cvscommit: # - Cameron Simpson <cs@zip.com.au> 12apr1997 cvscommit: # cvscommit-editor: #!/bin/sh cvscommit-editor: # cvscommit-editor: # Wrapper for $EDITOR for cvs commits to append the changes for inquisition cvscommit-editor: # in the change report. cvscommit-editor: # - Cameron Simpson <cs@zip.com.au> 09mar2002 cvscommit-editor: # cvsdiff: #!/bin/sh cvsdiff: # cvsdiff: # Default cvs diff run. - Cameron Simpson <cs@zip.com.au> 09mar2002 cvsdiff: # cvsdir: #!/bin/sh cvsdir: # cvsdir: # Import a directory into cvs. cvsdir: # - Cameron Simpson <cs@zip.com.au> 24aug96 cvsdir: # cvsedit: #!/bin/sh cvsedit: # cvsedit: # Update a file, edit it, run a commit, commit the file. cvsedit: # - Cameron Simpson <cs@zip.com.au> 05mar1997 cvsedit: # cvslog: #!/bin/sh cvslog2html - transcribe CVS logs to HTML or plain text cvspcs: #!/bin/sh cvspcs: # cvspcs: # Emit machine list via netgroup. cvspcs: # - Cameron Simpson <cs@zip.com.au> 24sep96 cvspcs: # cvsweb: #!/bin/sh darken: #!/bin/sh darken: # darken: # Emit a darkened version of an image on stdout, in JPEG format. darken: # Essentially a wrapper for ppmdim. darken: # - Cameron Simpson <cs@zip.com.au> 21jul2000 darken: # dat: #!/bin/sh data2cbytes: #!/usr/bin/perl data2cbytes: # data2cbytes: # Read binary data from stdin. Write C data bytes of the form 0xXX to stdout, data2cbytes: # suitable for inclusion in a C char array or Java byte array. data2cbytes: # - Cameron Simpson <cs@zip.com.au> 25apr2001 data2cbytes: # datevars: #!/usr/bin/perl datevars: # datevars: # Emit shell assignments to set date related variables. datevars: # - Cameron Simpson <cs@zip.com.au> 13aug99 datevars: # dbdump: #!/usr/bin/perl dbdump: # dbdump: # Dump a cs::Persist database. dbdump: # - Cameron Simpson <cs@zip.com.au> 13nov97 dbdump: # dbgroup: #!/usr/bin/perl dbgroup: # dbgroup: # Show or edit a group's membership. dbgroup: # - Cameron Simpson <cs@zip.com.au> 14mar2000 dbgroup: # dbgroup: # Enumerate groups directly listing a user. - cameron 02may2001 dbgroup: # dbi2csv: #!/usr/bin/perl dbi2csv: # dbi2csv: # Dump a MySQL table (later others, since it uses DBI) in .csv format. dbi2csv: # - Cameron Simpson <cs@zip.com.au> 30sep99 dbi2csv: # dblspc: #!/bin/sh dbm: #!/usr/bin/perl dbm: # dbm: # Simple dbm file querier. dbm: # dbm2gdbm: #!/bin/sh dbm2html: #!/usr/bin/perl dbm2html: # dbm2html: # Generate an HTML document describing the content of a DBM index. dbm2html: # Currently this is oriented around dbm2html: # dbsplit: #!/bin/sh dbsplit: # dbsplit: # Split flat db files into db directories. dbsplit: # - Cameron Simpson <cs@zip.com.au> 07nov97 dbsplit: # dbuser: #!/usr/bin/perl dbuser: # dbuser: # Edit a user's attributes. dbuser: # - Cameron Simpson <cs@zip.com.au> 07apr2000 dbuser: # dbuser: # Create new users, too. dbuser: # - Cameron Simpson <cs@zip.com.au> 11apr2000 dbuser: # # dcmp - compare or merge two directory trees ddi: #!/bin/sh ddo: #!/bin/sh deaduserdirs: #!/bin/sh deaduserdirs: # deaduserdirs: # List sizes of all directories for dead users, ordered by size. deaduserdirs: # - Cameron Simpson <cs@zip.com.au> 07mar2001 deaduserdirs: # deleted: #!/bin/sh deltail: #!/bin/sh depgpblock: #!/bin/sh depgpblock: # depgpblock: # Assumes gets all necessary args from environment variables. depgpblock: # (PGPPATH, PGPPASS) depgpblock: # depgpblock: # If can decrypt msg on stdin, then prints out decrypted message and returns 0. depgpblock: # Otherwise prints nothing useful and returns 1. depgpblock: # - Tim Knight, 27feb98 depgpblock: # depgpblock: # Cleanup and anti-argv-leakage security change. depgpblock: # - Cameron Simpson <cs@zip.com.au> 24apr98 depgpblock: # depgpmailitem: #!/usr/bin/perl depgpmailitem: # depgpmailitem: # Reads mail message from stdin, and prints it back out, with the PGP blocks depgpmailitem: # inside decrypted if the pass phrase required is supplied in the specified depgpmailitem: # file. depgpmailitem: # - Tim Knight, 27feb98 depgpmailitem: # depgpmailitem: # Further work, including security fixes. - cameron, 24apr98 depgpmailitem: # detab: #!/usr/bin/perl detab: # detab: # Usage: detab [-tabsize] [files...] detab: # dfh: #!/bin/sh dfh: # dfh: # df the local filesystems. dfh: # - Cameron Simpson <cs@zip.com.au> dfh: # dfk: #!/bin/sh dfk: # dfk: # df in kilobytes. dfk: # - Cameron Simpson <cs@zip.com.au> 24aug96 dfk: # dfltenv: #!/bin/sh dfltenv: # dfltenv: # Snarf system environment and then run command. dfltenv: # - Cameron Simpson <cs@zip.com.au> 27may1997 dfltenv: # dgrep: #!/bin/sh diffgroup: #!/usr/bin/perl diffgroup: # diffgroup: # Report differences between two group files. diffgroup: # - Cameron Simpson <cs@zip.com.au> 12dec97 diffgroup: # diffu: #!/bin/sh diffu: # diffu: # Wrapper for "diff -u". Supports line selection too. diffu: # - Cameron Simpson <cs@zip.com.au> diffu: # ding: #!/usr/bin/perl dir: #!/bin/sh dir2html: #!/bin/sh dir2html: # dir2html: # HTML index of a directory. dir2html: # - Cameron Simpson <cs@zip.com.au> 09oct96 dir2html: # dirs: #!/bin/sh dod: #!/bin/sh dod2html: #!/usr/bin/perl dod2html: # dod2html: # Produce the current DoD listing in HTML. dod2html: # dod | dod2html dod2html: # Notice URLs mentioned in the urls.html file. dod2html: # dod2mailrc: #!/usr/bin/perl dod2mailrc: # dod2mailrc: # Convert the DoD list to a mailrc. dod2mailrc: # Emit classification problems to stdout. dod2mailrc: # - Cameron Simpson <cs@zip.com.au>, 09sep94 dod2mailrc: # dodfaq: #!/bin/sh dodfaq: # dodfaq: # To Answer The Call. dodfaq: # dodftp: #!/bin/sh dodftp: # dodftp: # FTP to the DoD archive site. dodftp: # dodm: #!/bin/sh dodupd: #!/bin/sh doom: #!/bin/sh dosync: #!/bin/sh dpgp: #!/bin/sh dpgp: # dpp: #!/usr/bin/perl dpp: # dpp: # Simpleminded preprocessor which does dpp: # dpp: # #includes dpp: # #if perl-expr dpp: # #define sym text dpp: # #eval sym perl-expr dpp: # {ENVVAR} dpp: # dsp: #!/bin/sh dsync: #!/bin/sh dsync: # dsync: # Synchronise two directories. dsync: # Wrapper for rsync which takes two directories and synchronises them, dsync: # because rsync takes a directory and a parent and I keep forgetting. dsync: # - Cameron Simpson <cs@zip.com.au> 05oct98 dsync: # dtree: #!/bin/sh dtree: # An ancient incantation from the Ur-Net ... dtree: # dts: #!/usr/bin/perl dts: # dts: # ISO date ==> UNIX time. dts: # - Cameron Simpson <cs@zip.com.au> 27oct2000 dts: # dudiff: #!/usr/bin/perl dudiff: # dudiff: # Produce a difference listing of two du outputs. dudiff: # - Cameron Simpson <cs@zip.com.au> 24may95 dudiff: # dufs: #!/bin/sh dufs: # duk: #!/bin/sh duk: # duk: # du in kilobytes. duk: # - Cameron Simpson <cs@zip.com.au> 24aug96 duk: # dumbshar: #!/bin/sh dumbshar: # Dumbshar - shar up simple files. dumbshar: # dumpcshenv: #!/bin/tcsh -f dumpcshenv: # dumpcshenv: # Source csh (gack!) script(s) then dumpenv. dumpcshenv: # - Cameron Simpson <cs@zip.com.au> 04may98 dumpcshenv: # dumpenv: #!/usr/bin/perl dumpenv: # dumpenv: # Emit shell script to reload environment. dumpenv: # - Cameron Simpson 15may93 dumpenv: # dumpenv: # Csh hack. - cameron, 23sep96 dumpenv: # Use cs::Shell.- cameron, 01dec98 dumpenv: # Persist Hack. - cameron, 02dec98 dumpenv: # dumphotlist: #!/usr/bin/perl dumphotlist: # dumphotlist: # Read hotlists, print in canonical form, clean lists. dumphotlist: # - Cameron Simpson <cs@zip.com.au> 06sep95 dumphotlist: # dumpuser: #!/bin/sh dumpuser: # dumpuser: # Dump users to archive. dumpuser: # dumpuser: # Usage: dumpuser <<-X dumpuser: # login dirs... dumpuser: # ... dumpuser: # X dumpuser: # dumpuser: # - Cameron Simpson, 26may93 dumpuser: # dupcs: #!/bin/sh dupd: #!/bin/sh dupd: # dupd: # Notice changes in disc usage. dupd: # - Cameron Simpson <cs@zip.com.au> dupd: # dupd: # Timestamping. - cameron, 21mar99 dupd: # dupmodes: #!/usr/bin/perl dupmodes: # dupmodes: # Read path pairs from stdin and copy the modes from one to the other. dupmodes: # - Cameron Simpson <cs@zip.com.au> 30sep99 dupmodes: # durep: #!/bin/sh durep: # durep: # Take the .du-s file from dusum and produce a report of disc usage by user durep: # and category. - Cameron Simpson, 23jun94 durep: # dusum: #!/bin/sh dusum: # dusum: # Produce disc usage summaries. dusum: # - Cameron Simpson <cs@zip.com.au> dusum: # dusum: # Extensions and usage. - cameron, 21mar99 dusum: # dvdlabel: #!/bin/sh dvdlabel: # dvdlabel: # Emit a DVD or CD label as PostScript. dvdlabel: # - Cameron Simpson <cs@zip.com.au> 17nov97 dvdlabel: # e: #!/bin/sh e: # e: # As with t, v and x, edit a file. e: # - Cameron Simpson <cs@zip.com.au> 04may2002 e: # edb: #!/usr/bin/perl edb: # edb: # - Cameron Simpson <cs@zip.com.au> edb: # edit: #!/bin/sh edit: # edit: # Edit a file, making a template if needed. edit: # - Cameron Simpson <cs@zip.com.au> 27oct95 edit: # editgroup: #!/bin/sh edittable: #!/usr/bin/perl -w edittable: # edittable: # Edit a column of a MySQL table (later others, since it uses DBI). edittable: # - Cameron Simpson <cs@zip.com.au> 24apr2001 edittable: # edituser: #!/bin/sh edsl: #!/usr/bin/perl edsl: # edsl: # Edit symlinks. edsl: # - Cameron Simpson <cs@zip.com.au> 07mar2001 edsl: # edsymlink: #!/usr/bin/perl edsymlink: # edsymlink: # Edit the named symlinks. edsymlink: # - Cameron Simpson <cs@zip.com.au>, 01sep94 edsymlink: # eg: #!/bin/sh email-summary-line: #!/bin/sh email-summary-line: # email-summary-line: # Read an email message from stdin and recite a summary line. email-summary-line: # - Cameron Simpson <cs@zip.com.au> 16apr2002 email-summary-line: # enmime: #!/bin/sh enmime: # enmime: # Read a nonMIME message and unpack any uuencoded sections, enmime: # reassemble as MIME enmime: # - Cameron Simpson <cs@zip.com.au> 12jun2002 enmime: # enq: #!/usr/bin/perl enq: # entar: #!/usr/bin/perl entar: # entar: # Run tar create with tidier verbose mode. entar: # - Cameron Simpson <cs@zip.com.au> 27jun2000 entar: # entilde: #!/bin/sh entilde: # entilde: # Put ~ in place of the user's home directory. entilde: # Usually a postfilter for psa and psu. entilde: # - Cameron Simpson <cs@zip.com.au> entilde: # enum: #!/usr/bin/perl enum: # envssh: #!/bin/sh envssh: # envssh: # Ssh, obtain normal env, run command. envssh: # - Cameron Simpson <cs@zip.com.au> envssh: # envssh-basic: #!/bin/sh envssh-basic: # envssh-basic: # Like envssh, but much simpler and faster. envssh-basic: # - Cameron Simpson <cs@zip.com.au> 20jan1999 envssh-basic: # envsub: #!/usr/bin/perl envsub: # envsub: # Substitute environment parameters into text. envsub: # Lifted from my myke rule for installing manuals. envsub: # - Cameron Simpson, 22jun1993 envsub: # eps: #!/usr/bin/perl eps: # eps: # Suck in an EPS file and emits PS to print it at a given point at a eps: # given size. eps: # Default point: 0,0 eps: # Default size: natural size. eps: # - Cameron Simpson <cs@zip.com.au> 21oct94 eps: # erg: #!/bin/sh errno: #!/bin/sh espadd: #!/bin/sh espadd: # espadd: # Submit addresses to ESP <http://www.mailbox.co.uk/esp/>. espadd: # - Cameron Simpson <cs@zip.com.au> 08feb96 espadd: # et: #!/bin/sh et: # et: # Wrapper for eterm. et: # - Cameron Simpson <cs@zip.com.au> 10may99 et: # etcsystem: #!/usr/bin/perl etcsystem: # etcsystem: # Update a solaris /etc/system file with the specified values. etcsystem: # Reads /etc/system formatted lines from stdin and updates the file with etcsystem: # the max of the input value and the value in the file. etcsystem: # - Cameron Simpson <cs@zip.com.au> 18jan2001 etcsystem: # ethstats: #!/bin/sh ethstats2generic: #!/usr/bin/perl ethstats2generic: # ethstats2generic: # Read a log from ethstats and emit data suitable for use by logtally. ethstats2generic: # - Cameron Simpson <cs@zip.com.au> 15oct2000 ethstats2generic: # ethstats2rrd: #!/usr/bin/perl ethstats2rrd: # ethstats2rrd: # Read an ethstats file on stdin and run rrdtool update commands. ethstats2rrd: # - Cameron Simpson <cs@zip.com.au> 27oct2000 ethstats2rrd: # evndx: #!/bin/sh evndx: # evndx: # Peruse a list of date-named files, directories and references and emit an evndx: # ordered HTML index. evndx: # - Cameron Simpson <cs@zip.com.au> 03may96 evndx: # execif: #!/bin/sh execif: # execif: # Exec command only if input is not empty. execif: # - Cameron Simpson <cs@zip.com.au> 23jun98 execif: # execonly: #!/bin/sh execonly: # execonly: # Stub to do nothing in place of some services like ssh-agent. execonly: # - Cameron Simpson <cs@zip.com.au> 14jan98 execonly: # exfwd: #!/usr/bin/perl exfwd: # exfwd: # Forwarder for people who've left. exfwd: # - Cameron Simpson <cs@zip.com.au> 28aug96 exfwd: # exfwd: # Port for postfix/procmail. - cameron 08jun2000 exfwd: # exists: #!/bin/sh exists: # exists: # Test for existence. (Stock test needs a -e like perl). exists: # - Cameron Simpson <cs@zip.com.au> 22aug2000 exists: # expalias: #!/usr/bin/perl expalias: # expalias: # Expand aliases. Assumes they're in the NIS (aka YP). expalias: # - Cameron Simpson <cs@zip.com.au> 29jun99 expalias: # expand: #!/usr/bin/perl expand: # expand: # Usage: detab [-tabsize] [files...] expireddu: #!/bin/sh expireddu: # expireddu: # Stand in a user homedir partition (eg /home/elph) and expireddu: # produces a sorted du of the directories of expired users expireddu: # (for archiving selection). expireddu: # - Cameron Simpson <cs@zip.com.au> 11jul2001 expireddu: # expn: #!/bin/sh expuser: #!/usr/bin/perl expuser: # expuser: # Expire a user. expuser: # - note their expiry date (today!) expuser: # - collect group membership into CONTACT list, expuser: # purge group membership expuser: # Note that this _only_ does the DB mods - no data archiving expuser: # or password cancellation is done. expuser: # - Cameron Simpson <cs@zip.com.au> 09jan98 expuser: # exrdb: #!/bin/sh exrdb: # faces-w: #!/usr/bin/perl faces-w: # faces-w: # Emit a faces(1) input list from the w(1) command. faces-w: # - Cameron Simpson <cs@zip.com.au> 26apr2002 faces-w: # faq: #!/bin/sh faq: # faq: # Emit the requested FAQ. faq: # - Cameron Simpson <cs@zip.com.au> 03aug95 faq: # faxspool: #!/bin/sh faxspool: # faxspool: # Complete rewrite of the faxspool script. faxspool: # - Cameron Simpson <cs@zip.com.au> 23may1997 faxspool: # faxtxt: #!/bin/sh faxtxt: # faxtxt: # Dispatch text to the FAX service. faxtxt: # - Cameron Simpson <cs@zip.com.au> 12apr95 faxtxt: # fdb: #!/usr/bin/perl fdb: # fdb: # Do stuff with the file database. fdb: # - Cameron Simpson <cs@zip.com.au> 21jul2000 fdb: # fdtee: #!/usr/bin/perl fdtee: # fetchback: #!/bin/sh fetchback: # fetchnews: #!/usr/bin/perl -w fetchnews: # fetchsquidlogs: #!/bin/sh fetchsquidlogs: # fetchsquidlogs: # Nab the logs from the web proxy. fetchsquidlogs: # - Cameron Simpson <cs@zip.com.au> fetchsquidlogs: # fextract: #!/usr/bin/perl fextract: # fextract: # Extract data from a stream. fextract: # - Cameron Simpson, 18jan94 fextract: # ffcat: #!/bin/sh ffcat: # ffcat: # List files with form feeds between them. ffcat: # - Cameron Simpson <cs@zip.com.au> 14nov97 ffcat: # filemail: #!/bin/sh filemail: # filemail: # File a single mail file in a specific folder. filemail: # - Cameron Simpson <cs@zip.com.au> 06may2002 filemail: # filemailitem: #!/bin/sh filemailitem: # filemailitem: # Read mail item from stdin, file in MH folder. filemailitem: # I can never remember just how to invoke rcvstore... filemailitem: # - Cameron Simpson <cs@zip.com.au> 20apr2001 filemailitem: # filensmail: #!/bin/sh filensmail: # filensmail: # Refile any netscape mail folders into my real mail folders. filensmail: # - Cameron Simpson <cs@zip.com.au> filensmail: # files: #!/bin/sh filestats: #!/usr/bin/perl filestats: # filestats: # Read filestats: # size path filestats: # from stdin, write stats to stdout. filestats: # - Cameron Simpson <cs@zip.com.au> 07jun99 filestats: # filter_fd: #!/bin/sh filter_fd: # filter_fd: # Filter an output filedescriptor. filter_fd: # - Cameron Simpson <cs@zip.com.au> 06may99 filter_fd: # filter_fd: # Multiple fds. - cameron, 23may99 filter_fd: # filteredit: #!/bin/sh filteredit: # filteredit: # Run a file through a filter and rewrite the file. filteredit: # Do not rewrite if error or unchanged or empty result. filteredit: # - Cameron Simpson <cs@zip.com.au> 16jun99 filteredit: # findbase: #!/usr/bin/perl findbase: # findbase: # Read filenames from stdin. findbase: # Report basename and the directories in which it occurs on stdout. findbase: # - Cameron Simpson <cs@zip.com.au> 28nov97 findbase: # findem: #!/bin/sh findem: # findexttbl: #!/bin/sh findexttbl: # findexttbl: # Search the exttable (on stdin) for the named extensions. findexttbl: # - Cameron Simpson <cs@zip.com.au> 24dec97 findexttbl: # findmail: #!/usr/bin/perl_gdbm findmail: # findmail: # Print Message-IDs of messages containing all specified patterns. findmail: # findwords: #!/bin/sh findwords: # findwords: # Find several words (egrep regexps) in files; findwords: # order the found files on the hit rate. findwords: # - Cameron Simpson <cs@zip.com.au> 30jan97 findwords: # fixd_users: #!/usr/bin/perl fixd_users: # fixd_users: # Usage: fixd_users machines... fixd_users: # fixd_users: # Each machine is translated: fixd_users: # H-machine -> machine fixd_users: # L-lab -> machines in lab fixd_users: # machine -> machine fixd_users: # A file d_users/machine is created per machine. fixd_users: # fixexts: #!/bin/sh fixexts: # fixexts: # Examine the named files and attach correct extensions to misnamed ones. fixexts: # - Cameron Simpson <cs@zip.com.au> 22feb1999 fixexts: # fixhtml: #!/usr/bin/perl fixhtml: # fixhtml: # Simple program to read HTML and emit clean HTML. fixhtml: # - Cameron Simpson <cs@zip.com.au> 31jul96 fixhtml: # fixlastnl: #!/bin/sh fixlastnl: # fixlastnl: # Read some input and make sure it has a trailing newline. fixlastnl: # Why? Sed has historically discarded unterminated last lines, fixlastnl: # and I've just discovered that bash does so too in backticks. fixlastnl: # Which is slack. fixlastnl: # - Cameron Simpson <cs@zip.com.au> 31may2002 fixlastnl: # fixnewsrc: #!/bin/sh fixnewsrc: # fixnewsrc: # Usage: fixnewsrc < old-newsrc > new-newsrc fixnewsrc: # fixnsr-linux: #!/bin/sh fixnsr-solaris: #!/bin/sh flat: #!/usr/bin/perl flatten: #!/bin/sh floorplan-data: #!/usr/bin/perl -w floorplan-data: # floorplan-data: # Emit floorplan coordinates and labels for the given piece of information. floorplan-data: # - Cameron Simpson <cs@zip.com.au> 09jan2002 floorplan-data: # fmogrify: #!/bin/sh fmogrify: # fmogrify: # Wrapper for ImageMagick's mogrify so I can pipe into it. fmogrify: # - Cameron Simpson <cs@zip.com.au> 16oct2000 fmogrify: # fold: #!/usr/bin/perl foreach: #!/bin/sh foreach: # foreach: # For line of stdin, run the supplied command with the line as argument, foreach: # in parallel. Serialise output so it doesn't overlap. foreach: # - Cameron Simpson <cs@zip.com.au> 28jul2000 foreach: # foreach2: #!/bin/sh foreach2: # foreach2: # For line of stdin, run the supplied command with the line as argument, foreach2: # in parallel. Serialise output so it doesn't overlap. foreach2: # - Cameron Simpson <cs@zip.com.au> 28jul2000 foreach2: # forktail: #!/bin/sh forktail: # forwtee: #!/bin/sh fplan: #!/bin/sh fsp: #!/usr/bin/perl fsp: #!/opt/bin/perl_dbm ftpdir: #!/bin/sh ftpdir: # fullnamefwd: #!/usr/bin/perl fullnamefwd: # fullnamefwd: # Forwarder for guess-their-name aliases. fullnamefwd: # Simple rip off of exfwd. fullnamefwd: # The main smarts are in updaliases, including the short circuit to fullnamefwd: # direct delivery when there is only one match. fullnamefwd: # - Cameron Simpson <cs@zip.com.au> 08jun2000 fullnamefwd: # fvwm-menu: #!/bin/sh fvwm-menu: # fvwm-menu: # Generate a self generating FVWM menu. fvwm-menu: # - Cameron Simpson <cs@zip.com.au> 18may2002 fvwm-menu: # fvwm-menu-scr: #!/bin/sh fvwm2automenus: #!/usr/bin/perl fvwm2automenus: # fvwm2automenus: # Generate some menus for fvwm2. fvwm2automenus: # - Cameron Simpson <cs@zip.com.au> 24apr99 fvwm2automenus: # fvwm2automenus: # Recode in perl for sheer speed. - cameron, 26apr99 fvwm2automenus: # fvwm2newdesk: #!/bin/sh fvwm2newdesk: # fvwm2newdesk: # Allocate a new workspace for fvwm2. fvwm2newdesk: # fvwm2newdesk: # fvwmevlog: #!/bin/sh fvwmmon: #!/usr/bin/perl fvwmmon: # fvwmmon: # Watch the FVWM Event Log and do stuff when things happen. fvwmmon: # Spurred into implementation by Mozilla 0.9.3's completely fucked new window fvwmmon: # placement policy. fvwmmon: # - Cameron Simpson <cs@zip.com.au> 20aug2001 fvwmmon: # fw: #!/bin/sh fw: # fw: # Usage: fw [-p subject_prefix] m-args... fw: # - Cameron Simpson <cs@zip.com.au> fw: # fwd: #!/usr/bin/perl fwd: # fwd: # Forwarder for people who've left and for full-name aliases. fwd: # - Cameron Simpson <cs@zip.com.au> 28aug96 fwd: # fwdsmtpcskk: #!/bin/sh fwmbox: #!/bin/sh fwmbox: # fwmbox: # Forward the contents of a UNIX mailbox. fwmbox: # - Cameron Simpson <cs@zip.com.au> 10dec97 fwmbox: # fwr: #!/bin/sh fwr: # fwr: # "Forward raw". Call fw but don't trash the From: line. fwr: # - Cameron Simpson <cs@zip.com.au> 10aug98 fwr: # g: #!/bin/sh g+s: #!/bin/sh gcc_clean: #!/usr/bin/perl gcc_clean: # gcc_clean: # Invoke @ARGV and filter output. gcc_clean: # gccanal: #!/bin/sh gccanal: # gccanal: # Gcc with pretty much everything turned on, for maximally gccanal: # paranoid code (well, it gets a lot of the common things). gccanal: # - Cameron Simpson <cs@zip.com.au> 28mar1999 gccanal: # gccanal: # Filter out some noise. - cameron, 24may1999 gccanal: # And then the superficially bogus "In function" message. - cameron 11jun2000 gccanal: # gccanal: ## set -x get-ssh-agent: #!/bin/sh get-ssh-agent: # get-ssh-agent: # Get the daemonised ssh-agent info. get-ssh-agent: # - Cameron Simpson <cs@zip.com.au> 30jul2001 get-ssh-agent: # get-ssh-hostkey: #!/bin/sh getfile: #!/usr/bin/perl getfile: # getfile: # Getfile/sendfile hack. getfile: # - Cameron Simpson <cs@zip.com.au> 03mar95 getfile: # getlost: #!/usr/bin/perl getlost: # getoptusmail: #!/bin/sh getoptusmail: # getoptusmail: # Fetchmail from optus@home, forward to zip. getoptusmail: # - Cameron Simpson <cs@zip.com.au> 09nov2000 getoptusmail: # getpageurls: #!/bin/sh getpageurls: # getpgpkeyid: #!/bin/sh getpgpkeyid: # getpgpkeyid: # Given key ids, fetch data from Bal's Public Key Server. getpgpkeyid: # - Cameron Simpson <cs@zip.com.au> 01feb2000 getpgpkeyid: # getsnoopstats: #!/bin/sh getsnoopstats: # getsnoopstats: # Gather stats for later graphing. getsnoopstats: # - Cameron Simpson <cs@zip.com.au> 15jan99 getsnoopstats: # getzipmail: #!/bin/sh getzipmail: # getzipmail: # Grab my currently unforwarded email and file it. getzipmail: # - Cameron Simpson <cs@zip.com.au> 13jun2000 getzipmail: # gh: #!/bin/sh gids: #!/bin/sh gids: # gids: # List numeric group ids for a user by reverse "groups" list. gids: # - Cameron Simpson <cs@zip.com.au> 12jun2002 gids: # gif2jpg: #!/bin/sh gif2jpg: # gif2jpg: # - Cameron Simpson <cs@zip.com.au> gif2jpg: # gifstat: #!/usr/bin/perl gl: #!/bin/sh glob: #!/bin/sh glossary2html: #!/usr/bin/perl glossary2html: # glossary2html: # Read a file of the form: glossary2html: # ^\S.* glossary2html: # \s.* ... glossary2html: # and emit an HTML index. glossary2html: # - Cameron Simpson <cs@zip.com.au> 29nov96 glossary2html: # gn: #!/bin/sh gopherget: #!/usr/bin/perl gopherget: # gopherget: # Collect a file via Gopher. gopherget: # gpu: #!/bin/sh gpu: # gpu: # Asynchronous getpageurls. - Cameron Simpson <cs@zip.com.au> gpu: # gpu: # hack to permit leading subdir prefix gpui: #!/bin/sh grabaddrs: #!/usr/bin/perl grabaddrs: # grabaddrs: # Read RFC822 headers on stdin and emit addresses suitable for use in Mutt external queries. grabaddrs: # - Cameron Simpson <cs@zip.com.au> 31jan2001 grabaddrs: # grabmlru: #!/bin/sh grabmlru: # grabmlru: # Collect Carl Paukstis' Mailing List Round-Up and update my HTMLised version. grabmlru: # - Cameron Simpson <cs@zip.com.au> 05mar2002 grabmlru: # grabstdin: #!/bin/sh grabstdin: # grabstdin: # Collect stdin and bg the named command, sending output to the grabstdin: # console log, IGNHUPed. grabstdin: # - Cameron Simpson <cs@zip.com.au> 16sep98 grabstdin: # grepall: #!/bin/sh grepall: # grepall: # Grep all lines from stdin containing all the command line regexps. grepall: # - Cameron Simpson <cs@zip.com.au> 12nov2001 grepall: # grepliveusers: #!/usr/bin/perl grepliveusers: # grepliveusers: # Read users from stdin, write live ones to stdout, and to stderr: grepliveusers: # user complaint grepliveusers: # grepliveusers: # Zero exit status if everyone is live. grepliveusers: # - Cameron Simpson <cs@zip.com.au> 14jul98 grepliveusers: # grepliveusers: # Port to MSQ. - Cameron Simpson <cs@zip.com.au> 10may2000 grepliveusers: # grepwideimg: #!/bin/sh grepwideimg: # grepwideimg: # List images whose width > height, eg to pick some wallpaper. grepwideimg: # - Cameron Simpson <cs@zip.com.au> 28feb2001 grepwideimg: # group: #!/bin/sh group: # group: # Print group members. group: # - Cameron Simpson <cs@zip.com.au> 12mar96 group: # groupcheck: #!/bin/sh groupcheck: # groupnames: #!/usr/bin/perl groupnames: # groupnames: # Repport all the aliases for a group. groupnames: # - Cameron Simpson <cs@zip.com.au> 21nov2000 groupnames: # groups2ldif: #!/usr/bin/perl groups2ldif: # groupshare: #!/bin/sh groupshare: # groupshare: # Configure a directory tree for group sharing: groupshare: # - chgrp to named group groupshare: # - group r/w groupshare: # - setgid dirs groupshare: # - Cameron Simpson <cs@zip.com.au> 27sep2000 groupshare: # gs10: #!/bin/sh gs10: # gs10: # Quick'n'dirty upload from Canon digital camera. gs10: # - Cameron Simpson <cs@zip.com.au> 12aug2001 gs10: # gz: #!/bin/sh hdb: #!/bin/sh hdb: # hdb: # Edit files in the wiring database while holding a lock. hdb: # - Cameron Simpson <cs@zip.com.au> hdb: # hdb2csv: #!/usr/bin/perl hdb2csv: # hdb2csv: # Quick CSV summary of host data for accounts. hdb2csv: # - Cameron Simpson <cs@zip.com.au> 16feb2001 hdb2csv: # hdb2js: #!/usr/bin/perl hdb2js: # hdb2js: # Convert cs::Hier dbs into JavaScript code. hdb2js: # - Cameron Simpson <cs@zip.com.au> 17apr98 hdb2js: # # hdbinfo - print fields from the hosts database hdraddrs: #!/usr/bin/perl hdraddrs: # hdraddrs: # Return the addresses from a set of headers. hdraddrs: # - Cameron Simpson <cs@zip.com.au> 24may2002 hdraddrs: # hexify: #!/usr/bin/perl hexify-GETfield: #!/bin/sh hexify-GETfield: # hexify-GETfield: # Escape the value of a query value for URL embedding. hexify-GETfield: # - Cameron Simpson <cs@zip.com.au> 19nov98 hexify-GETfield: # hfiles: #!/bin/sh hfiles: # hfiles: # Return a list of all *.h files. hfiles: # It's surprising how often I want this. hfiles: # - Cameron Simpson <cs@zip.com.au> 09jul2001 hfiles: # hg: #!/bin/sh hg: # hg: # Asynchronous httpget. - Cameron Simpson <cs@zip.com.au> hg: # hi: #!/bin/sh hi: # hi: # The good morning stuff. - Cameron Simpson <cs@zip.com.au> hi: # highlight: #!/usr/bin/perl highlight: # highlight: # Highlist (by overstriking) text matching a regexp in the input. highlight: # - Cameron Simpson <cs@zip.com.au> highlight: # histbackup: #!/bin/sh histbackup: # histbackup: # Backup a directory to an indefinite file store using an incremental histbackup: # technique. Also see the rab script, which is an easy to use wrapper. histbackup: # - Cameron Simpson <cs@zip.com.au> 03apr2000 histbackup: # histbackup: # --inplace histbackup: # Specify parent dir, backup parent/current to parent/datestamp. histbackup: # - Cameron Simpson <cs@zip.com.au> 11apr2000 histbackup: # histbackup: # --mono histbackup: # Monotonic accumulation of data: just don't use --delete with rsync :-) histbackup: # To be used for the downloads archive. histbackup: # - Cameron Simpson <cs@zip.com.au> 17may2000 histbackup: # histbackup: # --linkonly histbackup: # Specify the parent backupdir only, and omit the rsync. histbackup: # Emit backupdir linktree subdir name on stdout. histbackup: # - Cameron Simpson <cs@zip.com.au> 28jun2001 histbackup: # histbackup: # --no-copy histbackup: # Passed to linktree. histbackup: # - Cameron Simpson <cs@zip.com.au> 03jul2001 histbackup: # histbackup: # --rsync-path rrsync histbackup: # Passed to rsync. histbackup: # - Cameron Simpson <cs@zip.com.au> 12jul2001 histbackup: # hm: #!/bin/sh hollow: #!/bin/sh hollow: # hollow: # Wrapper for things which dump core. hollow: # - Cameron, 29mar94 hollow: # Pulled out the hack to run different X servers, hollow: # it isn't needed anymore hollow: # - Aidan, 10Nov94 hollow: # hollow: # Options: hollow: # -c corelim Corelimits other than zero. hollow: # -d dir Cd to dir before running the requisite program. hollow: # homepop: #!/bin/sh hostalias: #!/bin/sh hostalias: # hostalias: # Record address of host. hostalias: # Mostly used to tell my main sites about where I just dialed in from. hostalias: # - Cameron Simpson <cs@zip.com.au> 25jul99 hostalias: # hostsync: #!/bin/sh hostsync: # hostsync: # Hotsync my Palm. hostsync: # - Cameron Simpson <cs@zip.com.au> 03apr2000 hostsync: # hotjava: #!/bin/sh hotlist2html: #!/usr/bin/perl hotlist2html: # hotlist2html: # Read hotlist data from stdin and emit HTML equivalent. hotlist2html: # - Cameron Simpson, cs@zip.com.au, 10jun94 hotlist2html: # hotlist2pndx: #!/bin/sh hotlist2pndx: # hotlist2pndx: # Convert hotlist data to an HTML permuted index. hotlist2pndx: # - Cameron Simpson <cs@zip.com.au> 06may97 hotlist2pndx: # hotsync: #!/bin/sh hotsync: # hotsync: # Backup my current hotsync and then sync from my palm. hotsync: # - Cameron Simpson <cs@zip.com.au> 03apr2000 hotsync: # hps: #!/bin/sh hps: # hps: # Emit machine list via netgroup. hps: # - Cameron Simpson <cs@zip.com.au> 24sep96 hps: # hsi: #!/usr/bin/perl hsi: # hsi: # Manage an hierachical subject index. hsi: # - Cameron Simpson <cs@zip.com.au>, 19jul94 hsi: # htauth: #!/usr/bin/perl htauth: # htauth: # Stash a login/password for use at a web site. htauth: # Naturally this is mega insecure (depending on cs::HTTP::Auth, but that htauth: # happens to be just a cleartext file) and so not for more that trivial uses. htauth: # - Cameron Simpson <cs@zip.com.au> htauth: # htc: #!/bin/sh htc: # htc: # Scour a web page with htclean. htc: # - Cameron Simpson <cs@zip.com.au> 02feb2001 htc: # htclean: #!/usr/bin/perl htclean: # htclean: # Do various scourings of input HTML. htclean: # - Cameron Simpson <cs@zip.com.au> 03mar99 htclean: # htclean-proxy: #!/usr/bin/perl htclean-proxy: # htclean-proxy: # Simple HTTP proxy to htclean a web feed. htclean-proxy: # - Cameron Simpson <cs@zip.com.au> 5jan2001 htclean-proxy: # htextract: #!/usr/bin/perl htextract: # htextract: # Extract tokens from HTML. htextract: # - Cameron Simpson, cs@zip.com.au, 15jun94 htextract: # htforms: #!/usr/bin/perl htforms: # htforms: # Extract forms from HTML. htforms: # - Cameron Simpson <cs@zip.com.au> 03mar99 htforms: # htg: #!/bin/sh html: #!/bin/sh html: # html: # List/manipulate info in HTML documents. html: # - Cameron Simpson <cs@zip.com.au> 21nov96 html: # html2mm: #!/usr/bin/perl html2mm: # html2mm: # Convert HTML to troff-mm macros for printing. html2mm: # - Cameron Simpson <cs@zip.com.au>, 08jul94 html2mm: # html2mm: # TABLE support. - cameron, 30jun98 html2mm: # Better nested tag support. - cameron, 01jul98 html2mm: # html2txt: #!/bin/sh html2txt: # html2txt: # Convert HTML to printable stuff. html2txt: # - Cameron Simpson <cs@zip.com.au> 21oct94 html2txt: # htmltst: #!/usr/bin/perl htmltst: # htmltst: # Convert HTML to troff-mm macros for printing. htmltst: # - Cameron Simpson <cs@zip.com.au>, 08jul94 htmltst: # htnisauth: #!/bin/sh htnisauth: # htnisauth: # Verify authentication using UNIX NIS crypt password for a CGI script. htnisauth: # - Cameron Simpson <cs@zip.com.au> 15feb2001 htnisauth: # htnisauth: # Exit status: htnisauth: # 0 Login and password match. htnisauth: # 1 Mismatch or lookup failure. htnisauth: # 2 Usage (invocation error). htnisauth: # htparse: #!/usr/bin/perl htparse: # htparse: # Extract tokens from HTML. htparse: # - Cameron Simpson, cs@zip.com.au, 15jun94 htparse: # htrewrite: #!/usr/bin/perl htrewrite: # htrewrite: # Read loose HTML, emit clean HTML. htrewrite: # - Cameron Simpson <cs@zip.com.au> 19dec97 htrewrite: # httables: #!/usr/bin/perl httables: # httables: # Extract tables from HTML. httables: # - Cameron Simpson <cs@zip.com.au> 03apr2001 httables: # http: #!/bin/sh httpget - download web pages httpquery: #!/usr/bin/perl httpquery: # httpquery: # Make a query for a GET-style form. httpquery: # - Cameron Simpson <cs@zip.com.au> 11dec96 httpquery: # httpwalk: #!/usr/bin/perl httpwalk: # httpwalk: # Walk an http hierarchy. - Cameron Simpson, 22mar94 httpwalk: # htv: #!/bin/sh htv: # htv: # Look at the results of an HTTP fetch. htv: # - Cameron Simpson <cs@zip.com.au> htv: # hxd: #!/usr/bin/perl hxd: # hxd: # Hex dump. - Cameron Simpson <cs@zip.com.au>, 04jul94 hxd: # # hzp - print files containing regexp with regexp highlighted icw: #!/usr/bin/perl icw: # icw: # Wrapper for icontact to figure out optimal layout for contact sheet. icw: # idis: #!/usr/bin/perl idis: # idis: # Emit project codes and related info. idis: # - Cameron Simpson <cs@zip.com.au> idis: # idis: # Ported to phase II timesheet system. - cameron 03nov99 idis: # ifmon: #!/usr/bin/perl ifmon: # ifmon: # Monitor throughput on the named interfaces. ifmon: # Linux specific, alas, since it uses the /proc/net/dev file. ifmon: # - Cameron Simpson <cs@zip.com.au> 22may2002 ifmon: # ifupdown: #!/bin/sh ifupdown: # ifupdown: # Set up/down network interface for movable machine. ifupdown: # May be able to get away with just "up". ifupdown: # - Cameron Simpson <cs@zip.com.au> 24jun2000 ifupdown: # ifupdown: # Disable NFS by default because Kath finds proper shutdown/startup ifupdown: # taxing. - cameron 22oct2000 ifupdown: # ignhup: #!/usr/bin/perl ignhup: # ignhup: # This was once a shell script saying ignhup: # ignhup: # trap '' 1; exec ${1+"$@"} ignhup: # ignhup: # but since AFAIK in perl you can't test for a signal being in "ignored" state ignhup: # some of my perl scripts which catch SIGHUP were undoing the simplicity of ignhup: # that, so I want a setsid as well, which means this becomes a perl script. ignhup: # - Cameron Simpson <cs@zip.com.au> 01aug2001 ignhup: # il2html: #!/bin/sh il2html: # il2html: # A spartan Interleaf->HTML by Hartmut Wilhelms <wilhelms@dfd.dlr.de> of the il2html: # Atmos Science Programme Office, German Remote Sensing Data Center. il2html: # It operates on Interleaf files saved in ASCII mode. il2html: # ilbmtogif: #!/bin/sh ilk: #!/bin/sh ilk: # ilk: # Are we of a particular ilk? ilk: # - Cameron Simpson <cs@zip.com.au> 07jun96 ilk: # im2html: #!/usr/bin/perl im2html: # im2html: # Produce gallery indices with and without frames. im2html: # - Cameron Simpson <cs@zip.com.au> 14feb96 im2html: # im2html: # Recode. - cameron 13apr99 im2html: # imagedb: #!/usr/bin/perl imagedb: # imindex: #!/usr/bin/perl imindex: # imresize: #!/bin/sh imresize: # imresize: # Squirrel away XbyY-sized versions of images. imresize: # - Cameron Simpson <cs@zip.com.au> 12feb98 imresize: # imscribe: #!/usr/bin/perl imscribe: # imscribe: # Inscribe text on an image. imscribe: # - Cameron Simpson <cs@zip.com.au> 13sep2000 imscribe: # imsize: #!/usr/bin/perl imsize: # imsize: # Report image sizes. imsize: # - Cameron Simpson <cs@zip.com.au> 01jun1999 imsize: # imsize: # Usage: imsize [filenames...] imsize: # imsize: # Output is imsize: # x y filename imsize: # for each supplied name. imsize: # imul: #!/usr/bin/perl -w imul: # imul: # Annotate a PNG image file, writing result to stdout. imul: # - Cameron Simpson <cs@zip.com.au> 08jan2002 imul: # inews: #!/usr/bin/perl inews: # inews: # Portable inews. inews: # - Cameron Simpson, 10nov93 inews: # inews: # Added code to supply missing From: line. - cameron, 07jan94 inews: # Obsoleted code to supply missing From: line because it didn't inews: # go well with the ->Post() method. - cameron, 08nov96 inews: # info2man: #!/bin/sh info2man: # info2man: # Convert info to -man format. info2man: # - Cameron Simpson <cs@zip.com.au> 01nov2000 info2man: # info2pod: #!/usr/bin/perl -w info2pod: # info2pod: # Convert info file into pod, largely because info2pod: # info2pod: # - info's too stupid to read stdin, so incorparating it info2pod: # into other tools sucks info2pod: # info2pod: # - I want my ordinary "man" command to find info files and info2pod: # do the right thing. info2pod: # info2pod: # - the GNU people are arrogant scum, and produce farces of info2pod: # manual entries, each prefaced with "we like info, info2pod: # so we don't maintain this page, and it's probably info2pod: # a pack of lies - go read the info file". Of course, info2pod: # the only way to do that is to fire up emacs or to info2pod: # use their weird info tool, which doesn't act much info2pod: # like a pager at all and violates the "use my preferred pager" info2pod: # approach people should be able to expect. info2pod: # info2pod: # Accordingly, since the Perl people can get this right (pod converts handily info2pod: # to all sorts of stuff), here is info2pod, which can be piped to pod2man info2pod: # to make manual entries. info2pod: # - Cameron Simpson <cs@zip.com.au> 14nov1999 info2pod: # info2pod: # Request from Hamish Macintyre <h.macintyre@ic.ac.uk> for this. info2pod: # Real coding begins. - 20sep2000 info2pod: # infotoc: #!/bin/sh infotoc: # infotoc: # Grep the node information from a GNU info file. infotoc: # - Cameron Simpson <cs@zip.com.au> 08sep99 infotoc: # initp: #!/bin/sh inondx: #!/usr/bin/perl_gdbm inondx: # inondx: # Update inode index from named files or stdin if none supplied. inondx: # install: #!/bin/sh iperl: #!/usr/bin/perl iperl: # iperl: # Interactive Perl. iperl: # iperl: # ! command Pass command to shell. $val <== $? iperl: # ? Print $val. iperl: # perl stuff $val <== eval 'perl stuff' iperl: # iperl: # Multiline perl text uses slosh extension. iperl: # - Cameron Simpson, 23feb93 iperl: # isodate: #!/bin/sh isodate: # isodate: # Return today's day code. - Cameron Simpson <cs@zip.com.au> 16jun1994 isodate: # ISOise the returns. - cameron 27mar1998 isodate: # Solaris 2.6 is feeding me full day and month names! - cameron 05apr2000 isodate: # Believe the claims that -% works everywhere these days. - cameron 06jun2000 isodate: # issymlink: #!/bin/sh issymlink: # issymlink: # Check is something is a symlink. issymlink: # - Cameron Simpson <cs@zip.com.au> 10nov2000 issymlink: # issymlink: # Switch from playing shell games to using readsymlink. issymlink: # - Cameron Simpson <cs@zip.com.au> 16oct2001 issymlink: # jargon: #!/bin/sh jargon: # jargon: # Consult the jargon file. - Cameron Simpson, 04nov92 jargon: # javaprereqs: #!/bin/sh jobs: #!/bin/sh jobs: # jobs: # Append to a log. jobs: # - Cameron Simpson <cs@zip.com.au> jobs: # jpg: #!/bin/sh jpgscale: #!/bin/sh jpgscale: # jpgscale: # Resize a JPEG image, outputs JPEG by default, with a few simple alternatives. jpgscale: # - Cameron Simpson <cs@zip.com.au> jpgscale: # jspref: #!/usr/bin/perl jspref: # jspref: # Simple stub to edit preferences.js files. jspref: # - Cameron Simpson <cs@zip.com.au> 25aug98 jspref: # juke: #!/bin/sh juke: # juke: # Simple jukebox. juke: # Runs a player in the background, reads keyword selections and commands juke: # in the foreground. juke: # - Cameron Simpson <cs@zip.com.au> 01jun2002 juke: # keepfirst: #!/bin/sh keeplast: #!/usr/bin/perl keeplast: # keeplast: # Keep first (or last) instances of lines in a file. keeplast: # Will take a regexp to match the section of the line of interest keeplast: # in identifying duplicates. keeplast: # Edits files in place if given filenames, otherwise is a pipe. keeplast: # - Cameron Simpson <cs@zip.com.au> keeplast: # kickme: #!/bin/sh killloadmeters: #!/bin/sh killvpnssh: #!/bin/sh killvpnssh: # killvpnssh: # Kill the ssh doing one of my VPNs. killvpnssh: # - Cameron Simpson <cs@zip.com.au> 25feb2000 killvpnssh: # killzdtexecs: #!/bin/sh killzdtexecs: # killzdtexecs: # CDE under Solaris 8 leaks dtexec processes. killzdtexecs: # This script tidies up. killzdtexecs: # - Cameron Simpson <cs@zip.com.au> 17oct2001 killzdtexecs: # kproc: #!/bin/sh kproc: # kproc: # Kill a process listed in a pid file. kproc: # - Cameron Simpson <cs@zip.com.au> 25feb2000 kproc: # l: #!/bin/sh label: #!/bin/sh label: # labhosts: #!/bin/ae labhosts: # lastrxvtbg: #!/bin/sh latest: #!/usr/bin/perl latest: # latest: # Given a listing of files, emit only the latest versions. latest: # Aimed primarily at things like the GNU source archive, which has many latest: # versions of things but of which we want to mirror only the latest. latest: # - Cameron Simpson <cs@zip.com.au> 17apr2001 latest: # latest: # Add -o to pass other, unversioned, files through. latest: # - cameron 07jun2001 latest: # lc: #!/bin/sh lcu: #!/bin/sh lcu: # My online banking. - Cameron Simpson <cs@zip.com.au> 13sep2001 lcu: # urlshow https://netteller.tsw.com.au/labs.asp & lcu2html: #!/usr/bin/perl lcu2html: # lcu2html: # Read a .CSV file from my credit union's internet banking facility lcu2html: # and emit an HTML table. lcu2html: # - Cameron Simpson <cs@zip.com.au> 04jun2001 lcu2html: # ldappwcp: #!/usr/bin/perl ldappwcp: # ldappwcp: # Emit password change requests for ldapmodify. ldappwcp: # - Cameron Simpson <cs@zip.com.au> ldappwcp: # ldapq: #!/bin/sh ldp: #!/bin/sh ldpath: #!/bin/sh ldpath: # ldpath: # Amend the LD_LIBRARY_PATH (which should normally be empty anyway) ldpath: # and then run some program which needs special lib loading. ldpath: # - Cameron Simpson <cs@zip.com.au> 04jan2001 ldpath: # leo: #!/bin/sh lgrep: #!/bin/sh lgrep: # lgrep: # Locate symbols in libraries. lgrep: # - Cameron Simpson <cs@zip.com.au> 10dec96 lgrep: # lib: #!/bin/sh libcat: #!/bin/sh libs: #!/bin/sh links: #!/bin/sh links: # links: # Find based on link count. links: # Leading arguments are shorthand: links: # +n Files with more than n links. links: # -n Files with less than n links. links: # n Files with exactly n links. links: # -ls Do an ls -ld of the file. links: # -rm Remove the file. links: # -x Print the find command issued. links: # links: # - Cameron Simpson <cs@zip.com.au> links: # linkstats: #!/usr/bin/perl linkstats: # linkstats: # - Cameron Simpson <cs@zip.com.au> linkstats: # linktree - make a hardlinked copy of a directory tree lintcs: #!/bin/sh listfiles: #!/bin/sh listfiles: # listfiles: # Offer a list of files. listfiles: # The common code from the bglist command, extracted to do generic selection listfiles: # to support picking audio files. listfiles: # - Cameron Simpson <cs@zip.com.au> 01jun2002 listfiles: # listserv2mj: #!/bin/sh listserv2mj: # listserv2mj: # Catch instructions for lists on majordomo and forward. listserv2mj: # - Cameron Simpson <cs@zip.com.au> 18jul96 listserv2mj: # liveusers: #!/usr/bin/perl liveusers: # liveusers: # Live users. liveusers: # - Cameron Simpson <cs@zip.com.au> liveusers: # lncp: #!/bin/sh lncp: # lncp: # Link or copy (link preferred). lncp: # - Cameron Simpson <cs@zip.com.au> lncp: # lntree: #!/usr/bin/perl lntree: # lntree: # Make a directory tree matching another, hardlinking the contents lntree: # from the original to the new one. lntree: # - Cameron Simpson <cs@zip.com.au> 25nov99 lntree: # loadav: #!/bin/sh localldpath: #!/bin/sh localldpath: # localldpath: # Wire in the core ldpath. localldpath: # - Cameron Simpson <cs@zip.com.au> 01feb2000 localldpath: # lock - obtain a lock before running a command locked: #!/bin/sh locked: # locked: # Check if a particular lock is taken. locked: # - Cameron Simpson <cs@zip.com.au> 03may1999 locked: # lockedcat: #!/bin/sh lockedcat: # lockedcat: # Sequenced cat command. See lockedoutput. lockedcat: # - Cameron Simpson <cs@zip.com.au> 25jul2000 lockedcat: # lockedit: #!/bin/sh lockedit: # lockedit: # Lock a file, edit, release. lockedit: # - Cameron Simpson <cs@zip.com.au> 16jun99 lockedit: # lockedoutput: #!/bin/sh lockedoutput: # lockedoutput: # Sequenced output. Used for shell loop parallelising, viz: lockedoutput: # lockedoutput: # for n in a b c ... lockedoutput: # do lockedoutput lockname command & lockedoutput: # done | something lockedoutput: # lockedoutput: # Runs "command" and takes lock when output commences so that lockedoutput: # the command outputs are not damaged through interleaving. lockedoutput: # - Cameron Simpson <cs@zip.com.au> 25jul2000 lockedoutput: # lockinfo: #!/bin/sh lockinfo: # lockinfo: # Report info on the named lock(s), or all locks. lockinfo: # - Cameron Simpson <cs@zip.com.au> 27may2002 lockinfo: # log: #!/bin/sh log: # log: # Pull out a change log from a CVS archive, reformat it nicely. log: # - Cameron Simpson <cs@zip.com.au> 12apr97 log: # logbuild: #!/bin/sh logbuild: # logbuild: # Run a new shell inside a script command, logging to the file logbuild: # $HOME/var/log/build/pkg-arch-host-date.gz logbuild: # Too often was I building things and losing the details. logbuild: # - Cameron Simpson <cs@zip.com.au> 28aug2000 logbuild: # logddtsemail: #!/bin/sh logddtsemail: # logddtsemail: # Log a ddts state change email. logddtsemail: # - Cameron Simpson <cs@zip.com.au> 12mar2001 logddtsemail: # loginenv: #!/bin/sh loginenv: # loginenv: # Obtain a user's login environment then run the supplied command. loginenv: # Requires that their login files be readable. loginenv: # Caveat: you're running this as _you_, so you're at the mercy of whatever loginenv: # they might stuff into their startup. loginenv: # - Cameron Simpson <cs@zip.com.au> 23mar99 loginenv: # logmap: #!/usr/bin/perl logmap: # logmap: # Manipulate the log map. logmap: # - Cameron Simpson <cs@zip.com.au>, 21jul94 logmap: # logpath: #!/bin/sh logpath: # logpath: # Return the path of a log. logpath: # - Cameron Simpson <cs@zip.com.au> 17may1997 logpath: # logproxy: #!/bin/sh logproxy: # logproxy: # Set up a server which forwards to another server, logging things as logproxy: # they go. Intended for debugging web transactions. logproxy: # - Cameron Simpson <cs@zip.com.au> 04sep2001 logproxy: # logpwd: #!/bin/sh logroll: #!/bin/sh logroll: # logroll: # Roll over a logfile; HUP daemon. logroll: # - Cameron Simpson <cs@zip.com.au> 10oct97 logroll: # logscript: #!/bin/sh logscript: # logscript: # Run and log a script session. logscript: # - Cameron Simpson <cs@zip.com.au> 18may2002 logscript: # logsquash: #!/usr/bin/perl logtally: #!/usr/bin/perl logtally: # logtally: # Parse generic logs and graph. Generalised from squidlogtally. logtally: # - Cameron Simpson <cs@zip.com.au> 14jan99 logtally: # logtally: # Input format: logtally: # start duration size class other-fields logtally: # Output: logtally: # PNG image logtally: # lomount: #!/bin/sh lomount: # lomount: # Do a loopback mount of a file containing a filesystem. lomount: # Linux specific at present. See also loumount. lomount: # - Cameron Simpson <cs@zip.com.au> 12jul2000 lomount: # loopstat: #!/bin/sh loopstat: # loopstat: # Hack to keep amd caching alive. Jeez. loopstat: # - Cameron Simpson, 01mar94 loopstat: # loumount: #!/bin/sh loumount: # loumount: # Reverse an lomount. See lomount. loumount: # - Cameron Simpson <cs@zip.com.au> 24nov2001 loumount: # lpqdup: #!/usr/bin/perl lpqdup: # lpqdup: # Usage: lpqdup queuename lpqdup: # lpqdup: # Walks the specified queue removing the second and following jobs for a user. lpqdup: # lprestart: #!/bin/sh lprestart: # lprestart: # Stop lp queue, flush, restart. lprestart: # - Cameron Simpson <cs@zip.com.au> 03mar98 lprestart: # lprestart: # Full paths for use via rsh etc. - cameron, 24jun98 lprestart: # lsdbm: #!/usr/bin/perl lsftp: #!/bin/sh lsn: #!/bin/sh lsn: # lsuser: #!/usr/bin/perl lsuser: # lsuser: # Report on users. lsuser: # - Cameron Simpson <cs@zip.com.au> 06may99 lsuser: # lt: #!/bin/sh ltr: #!/bin/sh ltrd: #!/bin/sh lwpr: #!/bin/sh lwpr: # # lz - print to postscript printers, doublesided with multiple pages to a sheet m: #!/usr/bin/perl m: # m: # Mail dispatch program, since I no longer use Rourke mail for this. m: # - Cameron Simpson, April 1992 m: # m: # Rewritten in perl, added .mailrc. - Cameron, 12sep92 m: # Got aliases working properly, added header rewrite code. - Cameron, 18oct92 m: # Added the Dumb PreProcessor code for header rewrites. - Cameron, 02nov93 m: # Dubious mailto: handling. - Cameron, 13jan99 m: # mac2cisco: #!/usr/bin/perl mac2cisco: # mac2cisco: # Convert an ethernet address into CISCO format. mac2cisco: # - Cameron Simpson <cs@zip.com.au> 19aug99 mac2cisco: # mail-fixhdrs: #!/bin/sed -f mail-fixhdrs: # mail-fixhdrs: # Fix some fuckups by egroups.com's digest maker. mail-fixhdrs: # - Cameron Simpson <cs@zip.com.au> 10jan2002 mail-fixhdrs: # mail2fax: #!/usr/bin/perl mail2fax: # mail2fax: # Take an email message aimed at a fax number and dispatch it into the mail2fax: # fax queue. mail2fax: # - Cameron Simpson <cs@zip.com.au> 23may1997 mail2fax: # maildiritem2fileitem: #!/bin/sed -f maildiritem2fileitem: # maildiritem2fileitem: # Convert a single file from a directory of single item mail files to maildiritem2fileitem: # something useful for storing in a UNIX format multiitem mail file. maildiritem2fileitem: # - Cameron Simpson <cs@zip.com.au> 27mar2000 maildiritem2fileitem: # maildrop: #!/bin/sh maildrop: # maildrop: # Queue mail for delivery. maildrop: # - Cameron Simpson <cs@zip.com.au> 26sep1996 maildrop: # maildrop: # Recoded in perl. - cameron, 07oct1994 maildrop: # Added requeue facility. - cameron, 10oct1994 maildrop: # Recoded in shell. - cameron, 26sep1996 maildrop: # mailif: #!/bin/sh mailif: # mailif: # Send mail only if input is not empty. mailif: # - Cameron Simpson <cs@zip.com.au> mailif: # mailif: # Usage: mailif [-s subject] addresses... mailif: # mailif: # Break into execif and mailsubj. - cameron, 23jun98 mailif: # mailman-procmail: #!/bin/sh mailman-procmail: # mailman-procmail: # Handler for email delivered to mailman. mailman-procmail: # Invoked from procmail. mailman-procmail: # mailman -> postmaster mailman-procmail: # mailman-list -> wrapper post list mailman-procmail: # mailman-list-admin -> wrapper mailowner list mailman-procmail: # mailman-list-request-> wrapper mailcmd list mailman-procmail: # mailman-list-owner -> mailman-list-admin mailman-procmail: # - Cameron Simpson <cs@zip.com.au> 16may2001 mailman-procmail: # mailsubj: #!/bin/sh mailsubj: # mailsubj: # Send mail with subject line. mailsubj: # - Cameron Simpson <cs@zip.com.au> 23jun98 mailsubj: # mailsum: #!/usr/bin/perl mailsum: # mailsum: # Summarise the named mail items to stdout. mailsum: # - Cameron Simpson <cs@zip.com.au>, 13jul94 mailsum: # mailtos: #!/bin/sh mailundigest: #!/bin/sh mailundigest: # mailundigest: # Wrapper for procmail and formail to explode a digest into a particular folder. mailundigest: # Based on the undigestifier in "man procmailex" but considerably fleshed out. mailundigest: # - Cameron Simpson <cs@zip.com.au> 09jan2002 mailundigest: # mailunpack: #!/bin/sh mailunpack: # mailunpack: # Extract all components of an email message with munpack, in a distinctively named directory. mailunpack: # If the shell script autoexec.sh is present in the key directory, run that after extraction. mailunpack: # - Cameron Simpson <cs@zip.com.au> 03dec2001 mailunpack: # man: #!/usr/bin/perl man: # man: # My manual command, having given up on the bogosities of the others. man: # - Cameron Simpson <cs@zip.com.au> 11may1997 man: # manpp: #!/bin/sh manpp: # manroff: #!/bin/sh manroff: # matchpwdlog: #!/usr/bin/perl matchpwdlog: # matchpwdlog: # Locate latest best match in pwdlog for use by cd alias. matchpwdlog: # - Cameron Simpson <cs@zip.com.au> 18feb98 matchpwdlog: # mbox-toc: #!/bin/sh mcat: #!/usr/bin/perl mcat: # mcat: # Output the contents of a MIME file, decoded. mcat: # - Cameron Simpson <cs@zip.com.au> mcat: # mcollate: #!/bin/sh mcollate: # mcollate: # Intercept email items and deposit in the named directories. mcollate: # - Cameron Simpson <cs@zip.com.au> 01nov96 mcollate: # mcollate: # Each directory contains a short shell script, viz: mcollate: # case "$subject" in mcollate: # shell-pattern) snarf=1 ;; # keep copies here mcollate: # pattern2) snarf=1 passthru= ;; # keep and not pass thru mcollate: # esac mcollate: # The variables $subject and $from are set to the first line of the respective mcollate: # headers with leading white space removed and upper case lowered. mcollate: # Setting $snarf to 1 will cause the item to be saved in the directory. mcollate: # Setting $passthru to the empty string will prevent delivery via normal mail mcollate: # (by default a copy arrives in the user's mail file, too). mcollate: # md2f: #!/bin/sh md2f: # md2f: # Collect a dir full of distinct mail files into a single UNIX mail file. md2f: # - Cameron Simpson <cs@zip.com.au> 03feb97 md2f: # md5comm: #!/usr/bin/perl md5comm: # md5comm: # Compare two md5index outputs after the fashion of comm(1), md5comm: # producing 3 columns of output: md5comm: # files present only in the first listing, or different md5comm: # files present only in the second listing, or different md5comm: # files present and the same in both md5comm: # md5comm: # - Cameron Simpson <cs@zip.com.au> 20jun2000 md5comm: # md5index: #!/usr/bin/perl md5index: # md5index: # Read filenames, emit "size:MD5 filename". md5index: # - Cameron Simpson <cs@zip.com.au> 27oct97 md5index: # md5index: # Recoded to use MD5 module and be simpler. - cameron 30nov1998 md5index: # Now lives off the cs::Image::DB module so they use the same hashes. md5index: # - cameron 13apr1999 md5index: # Back out to plain MD5 stuff. - cameron 20jun2000 md5index: # md5match: #!/bin/sh md5match: # md5match: # Read filenames from stdin and match them against md5indices md5match: # (as produced by the md5index script) named on the command line. md5match: # Output is lines containing either just: md5match: # size:md5\tfilename md5match: # for no match or md5match: # size:md5\tfilename\tmd5index\tindex-filename md5match: # for a match on an md5index file, with "index-filename" md5match: # being the name from the index. md5match: # - Cameron Simpson <cs@zip.com.au> 21jun2000 md5match: # md5medium: #!/bin/sh md5medium: # md5medium: # Save an md5index of a whole medium. md5medium: # - Cameron Simpson <cs@zip.com.au> 03jul2000 md5medium: # md5new: #!/bin/sh md5new: # md5new: # Read filenames from stdin and match against md5indices on the command line. md5new: # Emit filenames not known in the indices. md5new: # - Cameron Simpson <cs@zip.com.au> 21jun2000 md5new: # md5old: #!/bin/sh md5old: # md5old: # Read filenames from stdin and match against md5indices on the command line. md5old: # Emit filenames known in the indices as: md5old: # size:md5\tfilename\tmd5index\tindex-filename md5old: # as for md5match. md5old: # - Cameron Simpson <cs@zip.com.au> 21jun2000 md5old: # mdvd: #!/bin/sh mentor2ps: #!/bin/sh mentor2ps: # mentor2ps: # Adapted from the mentor print filters. mentor2ps: # - Cameron Simpson <cs@zip.com.au> 28nov2000 mentor2ps: # mentor2ps: # PLOT/EXPORT FILTER INVOCATION SCRIPT (FIS) mentor2ps: # This file sets up the environment for a Mentor Graphics Plot/Export mentor2ps: # Filter and invokes the filter executable. This file was automatically mentor2ps: # generated by the AMPLE tool $fis_builder(). mentor2ps: # mentor2ps: # Streams assigned by the printer daemon based on the printing environment mentor2ps: # that has been established by the Unix System Administrator are: mentor2ps: # mentor2ps: # stdin - the MGC job file mentor2ps: # stdout - the Unix device to receive the output mentor2ps: # stderr - an appropriate stream to receive warning and error messages mentor2ps: # mentor2ps: # Define the location of the MGC software tree mentor2ps: # mentor2ps-colour: #!/bin/sh mentorlp2lz: #!/bin/sh mentorlp2lz: # mentorlp2lz: # Wrapper to pretend to be Mentor-aware lp print command and pass to lz. mentorlp2lz: # - Cameron Simpson <cs@zip.com.au> 28nov2000 mentorlp2lz: # mentorlp2lz: ## exec 2>/dev/pts/43 meta: #!/usr/bin/perl meta: # mfiles: #!/bin/sh mfiles: # mfiles: # Invoke mutt to send several files. mfiles: # - Cameron Simpson <cs@zip.com.au> 28apr2001 mfiles: # mhdir: #!/bin/sh mhdir: # mhdir: # Make a mailbox folder and .mh_sequences (so mutt recognises it). mhdir: # - Cameron Simpson <cs@zip.com.au> 11oct1999 mhdir: # mhdrs: #!/usr/bin/perl mime: #!/usr/bin/perl mime: # mime: # Parse MIME messages. mime: # Currently a debugging tool. mime: # - Cameron Simpson <cs@zip.com.au> 04jun98 mime: # mj: #!/bin/sh mkbf: #!/bin/sh mkbf: # mkbf: # Make a ramdisk image after the fashion of mkinitrd. mkbf: # I wanted to be able to make a ramdisk without having an installed mkbf: # kernel, and possibly with other stuff on it. Mkinitrd seems too opinionated mkbf: # about what you want. Based heavily on mkinitrd and the mkbf: # /usr/src/linux/Documentation/ramdisk.txt mkbf: # file. mkbf: # - Cameron Simpson <cs@zip.com.au> 23jul2000 mkbf: # # mkcd - burn a data CD from an ISO image or data directory mkcf: #!/bin/sh mkcf: # mkcf: # Usage: mkcf dirs... mkcf: # mkciscoconfig: #!/usr/bin/perl mkciscoconfig: # mkciscoconfig: # Write configs for the named switch to stdout. mkciscoconfig: # - Cameron Simpson <cs@zip.com.au> 07jul98 mkciscoconfig: # mkcvsignore: #!/bin/sh mkcvsignore: # mkcvsignore: # Construct a .cvsignore file and commit it. mkcvsignore: # Should only be run when there is nothing more to add to CVS maintenance. mkcvsignore: # - Cameron Simpson <cs@zip.com.au> 28dec2001 mkcvsignore: # mkdatedfile: #!/bin/sh mkdatedfile: # mkdatedfile: # Given a prefix, create a file with a -date or -date-time suffix. mkdatedfile: # - Cameron Simpson <cs@zip.com.au> 31jul2000 mkdatedfile: # mkddtsrq: #!/bin/sh mkddtsrq: # mkddtsrq: # Submit a new DDTS request for SysAdmin. mkddtsrq: # Bug description on stdin. Other info on command line. mkddtsrq: # - Cameron Simpson <cs@zip.com.au> 13aug2001 mkddtsrq: # mkdirn: #!/bin/sh mkdirn: # mkdirn: # Make the next directory in a sequence. mkdirn: # Lifted from my cdfn shell function. mkdirn: # - Cameron Simpson <cs@zip.com.au> 28jun2000 mkdirn: # mkdirn: # Dash suffix if numeric prefix. - cameron 03sep2000 mkdirn: # Limit on number of directory tries. - cameron 05sep2000 mkdirn: # mkdvd: #!/bin/sh mkdvd: # mkdvd: # Run mkcd using cdrecord-prodvd, to burn a DVD. mkdvd: # - Cameron Simpson <cs@zip.com.au> 17jun2002 mkdvd: # mkdvdext2: #!/bin/sh mkdvdext2: # mkdvdext2: # Construct an ext2 fs on the DVD-RAM drive. mkdvdext2: # - Cameron Simpson <cs@zip.com.au> 10dec2000 mkdvdext2: # mkexttbl: #!/usr/bin/perl mkexttbl: # mkexttbl: # Dump ext -> user map from user db. mkexttbl: # - Cameron Simpson <cs@zip.com.au> 24dec97 mkexttbl: # mkfaq: #!/bin/sh mkfaq: # mkfaq: # Build an HTML FAQ from pieces. mkfaq: # - Cameron Simpson <cs@zip.com.au> 29jun98 mkfaq: # mkftpgroup: #!/bin/sh mkftpgroup: # mkfuncs: #!/usr/bin/perl mkfuncs: # mkfuncs: # C and C++ prototype generator. mkfuncs: # Believes fairly strongly in my formatting conventions. mkfuncs: # - Cameron Simpson <cs@zip.com.au> mkfuncs: # mkhomedir: #!/bin/sh mkhomedir: # mkhomedir: # Make standard home dir for new user. mkhomedir: # - Cameron Simpson <cs@zip.com.au> 12nov99 mkhomedir: # mkimlist: #!/bin/sh mkimlist: # mkimlist: # Generate a list of images with their sizes. mkimlist: # - Cameron Simpson <cs@zip.com.au> 09jan2002 mkimlist: # # mkiso - construct an ISO9660 CD image for burning a data CD mklinks - walk directories, linking identical files mklistgroups: #!/usr/bin/perl mklog: #!/bin/sh mklog: # mklog: # Make a new log file. mklog: # - Cameron Simpson <cs@zip.com.au> mklog: # mklp-sysv: #!/bin/sh mklp-sysv: # mklp-sysv: # Attach a remote BSD printer to the system. mklp-sysv: # - Cameron Simpson <cs@zip.com.au> 12dec96 mklp-sysv: # mkmailrcdb: #!/opt/bin/perl mkmailrcdb: # mkmailrcdb: # Read rawdb from stdin, write useful db to stdout. mkmailrcdb: # - Cameron Simpson <cs@zip.com.au> 30jul99 mkmailrcdb: # mkmjlist: #!/bin/sh mkmjlist: # mkmjlist: # Make a new mailing list. mkmjlist: # Should be run as root on the majordomo host. mkmjlist: # Expects Solaris (for the usertable stuff and location). mkmjlist: # - Cameron Simpson <cs@zip.com.au> 05jun96 mkmjlist: # mkmjusertable: #!/usr/bin/perl mkmjusertable: # mkmjusertable: # Make usertable entries for named (or all) majordomo lists. mkmjusertable: # - Cameron Simpson <cs@zip.com.au> mkmjusertable: # mkmjusertable: # Update for new db. - cameron 05jul2000 mkmjusertable: # mkmlinks: #!/bin/sh mkmlinks: # mkmlinks: # Rewrite /m symlinks to match amd.mentor NIS map. mkmlinks: # - Cameron Simpson <cs@zip.com.au> 07jun2001 mkmlinks: # mkmutgrp: #!/bin/sh mkmutgrp: # mkmutgrp: # mkmutgrp expiry members... mkmutgrp: # mkmydb: #!/bin/sh mkmydb: # mkmydb: # Make a virgin mysql data dir. mkmydb: # - Cameron Simpson <cs@zip.com.au> 03jul99 mkmydb: # mknetgroup: #!/usr/bin/perl mknetgroup: # mknetgroup: # Construct netgroups from the wiring database. mknetgroup: # - Cameron Simpson <cs@zip.com.au> 09sep2001 mknetgroup: # mknetid: #!/usr/bin/perl mknetid: # mknetid: # Replacement for Sun's mknetid because our group table has blown its mind. mknetid: # - Cameron Simpson <cs@zip.com.au> 18dec2001 mknetid: # mknfsstuff: #!/bin/sh mknfsstuff: # mknfsstuff: # Read a list of hosts and exported filesystems. mknfsstuff: # Make sure the mountpoints exist for the hosts not us. mknfsstuff: # Make sure symlinks exist for us. mknfsstuff: # Emit fstab lines. mknfsstuff: # - Cameron Simpson <cs@zip.com.au> 14oct2000 mknfsstuff: # mknphsshkey: #!/bin/sh mknphsshkey: # mknphsshkey: # Construct a passphraseless well commented and named ssh keypair. mknphsshkey: # - Cameron Simpson <cs@zip.com.au> 03feb2002 mknphsshkey: # mkopt: #!/bin/sh mkopt: # mkopt: # Make a directory in /usr/local/opt and link in /opt. mkopt: # For use with syncopt installs. mkopt: # - Cameron Simpson <cs@zip.com.au> 12dec2000 mkopt: # mkotpad: #!/bin/sh mkotpad: # mkotpad: # Generate a pad of random bytes and save under its MD5 hash. mkotpad: # Coded on the basis of David Madore's paper: mkotpad: # http://www.eleves.ens.fr:8080/home/madore/misc/freespeech.html mkotpad: # A damn fine idea. mkotpad: # - Cameron Simpson <cs@zip.com.au> mkotpad: # mkpatch: #!/bin/sh mkpatch: # mkpatch: # Usage: mkpatch [-v] [-c commentry] [--] olddir newdir mkpatch: # mkphonedir: #!/usr/bin/perl mkphonedir: # mkphonedir: # Emit the user portion of the phonedir file. mkphonedir: # - Cameron Simpson <cs@zip.com.au> 20nov97 mkphonedir: # mkpmlocs: #!/usr/bin/perl mkpmlocs: # mkpmlocs: # Emit commands for the PortMaster to write the dialback location table. mkpmlocs: # - Cameron Simpson <cs@zip.com.au> 11jun1997 mkpmlocs: # mkpmlocs: # Use auto/pmlocs table to preserve IP addrs. mkpmlocs: # Reuse IPs for people with ALTDIALBACK #s. - cameron 20nov1997 mkpmlocs: # Fold DIALBACKALT into DIALBACK. - cameron 07jan1998 mkpmlocs: # Port to MySQL db. - cameron 10aug2000 mkpmlocs: # mkprintcap: #!/bin/sh mkprintcap: # mkprintcap: # Emit an LPRng printcap for our printers. mkprintcap: # - Cameron Simpson <cs@zip.com.au> 12oct2000 mkprintcap: # mkpw: #!/bin/sh mkpw: # mkpw: # Make a random password string. mkpw: # - Cameron Simpson <cs@zip.com.au> 28feb2002 mkpw: # mkrc: #!/bin/sh mkrc: # mkrc: # Regenerate an rc file. mkrc: # - Cameron Simpson <cs@zip.com.au> 23aug98 mkrc: # mkrd: #!/bin/sh mkrd: # mkrd: # Make a ramdisk image after the fashion of mkinitrd. mkrd: # I wanted to be able to make a ramdisk without having an installed mkrd: # kernel, and possibly with other stuff on it. Mkinitrd seems too opinionated mkrd: # about what you want. Based heavily on mkinitrd and the mkrd: # /usr/src/linux/Documentation/ramdisk.txt mkrd: # file. mkrd: # - Cameron Simpson <cs@zip.com.au> 23jul2000 mkrd: # # mkscriptndx - produce a simple summary of the named scripts mksquid_redirect_ptns: #!/usr/bin/perl mksquid_redirect_ptns: # mksquid_redirect_ptns: # Read pattern specs from stdin and turn into perl code. mksquid_redirect_ptns: # Patterns are shell-style patterns, except that: mksquid_redirect_ptns: # ** matches strings including / mksquid_redirect_ptns: # ? is not a meta character mksquid_redirect_ptns: # . isn't either mksquid_redirect_ptns: # \ doesn't work mksquid_redirect_ptns: # - Cameron Simpson <cs@zip.com.au> 09apr99 mksquid_redirect_ptns: # mksshhostkey: #!/bin/sh mksshhostkey: # mksshhostkey: # The magic incantation to make an ssh host key file. mksshhostkey: # - Cameron Simpson <cs@zip.com.au> 12jul2000 mksshhostkey: # mktags: #!/usr/bin/perl mktags: # mktags: # Usage: mktags [-v] files... | sort -u > vi-tags mktags: # - Cameron Simpson <cs@zip.com.au> mktags: # mkthumbnail: #!/bin/sh mkthumbnail: # mkthumbnail: # Make thumbnail GIFs for inclusion in Web pages. mkthumbnail: # - Cameron Simpson <cs@zip.com.au> 19feb95 mkthumbnail: # mkthumbnail: # Prefer PNG to GIF, handle other input types. - cameron, 26may99 mkthumbnail: # mkulinks: #!/bin/sh mkulinks: # mkulinks: # Rewrite /u symlinks to match user db. mkulinks: # - Cameron Simpson <cs@zip.com.au> 10apr2001 mkulinks: # mkulinks: # Moved algorithm to updlinkforest. - cameron 07jun2001 mkulinks: # mkvpnsshkey: #!/bin/sh mkvpnsshkey: # mkvpnsshkey: # Construct an ssh keypair for a VPN. mkvpnsshkey: # - Cameron Simpson <cs@zip.com.au> 03feb2002 mkvpnsshkey: # mkvxfssnap: #!/bin/sh mkvxfssnap: # mkvxfssnap: # Make a snapshot of a Veritas filesystem. mkvxfssnap: # - Cameron Simpson <cs@zip.com.au> 31oct2000 mkvxfssnap: # ml: #!/usr/bin/perl mlinks: #!/bin/sh mlinks: # mlinks: # Emit the links which should be in /m. mlinks: # - Cameron Simpson <cs@zip.com.au> 07jun2001 mlinks: # mlist: #!/bin/sh mlist: # mlist: # Maintain mailing-list subscriptions. mlist: # - Cameron Simpson <cs@zip.com.au> 07sep95 mlist: # mlp: #!/bin/sh mlru2html: #!/usr/bin/perl mlru2html: # mlru2pl: #!/usr/bin/perl mlru2pl: # mlru2pl: # Parse Carl Paukstis's mailing list roundup and emit a Perl Hier file. mlru2pl: # - Cameron Simpson <cs@zip.com.au> 21jul95 mlru2pl: # mlrupd: #!/usr/bin/perl mlrupd: # mlrupd: # Update the mailist list DB from an Hier made from Carl's list. mlrupd: # - Cameron Simpson <cs@zip.com.au> 21jul95 mlrupd: # modules: #!/bin/sh modules: # modules: # monfile: #!/bin/sh monfile: # monfile: # Replace a file with stdin. monfile: # Output differences. monfile: # - Cameron Simpson <cs@zip.com.au> 04nov98 monfile: # monitor: #!/usr/bin/perl monitor: # monitor: # Do a tail-f watching for a pattern. monitor: # Report that line and the surrounding ones. monitor: # - Cameron Simpson <cs@zip.com.au> 12aug96 monitor: # monweblog: #!/usr/bin/perl mp: #!/bin/sh mpage: #!/bin/sh mpage: # mpage: # Wrapper for multi.ps. mpage: # Also adds duplexmode and tumble to control doublesiding of paper. mpage: # - Cameron Simpson, January 1992 mpage: # mpage: # Made operator replacement conditional upon operator existence. mpage: # Added -fg and -bg for colour control. - Cameron, 11may93 mpage: # Added papertray selection. - Cameron, 15mar94 mpage: # mpage: # Multi.ps is a groovy piece of PostScript written by: mpage: # mpage: # Ross Cartlidge mpage: # Information Technology Services mpage: # Building H08, Sydney University mpage: # NSW, 2006, Australia mpage: # mpage: # R.Cartlidge@isu.usyd.edu.au Email mpage: # +61 2 9351 5506 Phone mpage: # +61 2 9351 5001 Fax mpage: # mq: #!/bin/sh mrd: #!/usr/bin/perl mrd: # mrd: # Mail reader. mrd: # - Cameron Simpson <cs@zip.com.au> mrd: # mrg: #!/usr/bin/perl mrgdirs: #!/bin/sh mrgdirs: # mrgdirs: # Merge directories created with mkdirn into another directory mrgdirs: # of such subdirs. mrgdirs: # - Cameron Simpson <cs@zip.com.au> 31jan2001 mrgdirs: # mrgmhdirs: #!/bin/sh mrgmhdirs: # mrgmhdirs: # Merge the contents of one MH folder into another, mrgmhdirs: # and link the second back to the first as synonyms. mrgmhdirs: # Note: uses $MAILDIR instead of ~/.mh_profile. mrgmhdirs: # Assumes they match. mrgmhdirs: # - Cameron Simpson <cs@zip.com.au> 25may2002 mrgmhdirs: # mrgtags: #!/usr/bin/perl mrgtags: # mrgtags: # Usage: mrgtags [-d supposed-pwd] [tagfiles] mrgtags: # mrgtags: # Merges the tags provided, giving precedence to earlier tags. mrgtags: # mring: #!/bin/sh mring: # mring: # Ring my mail data. mring: # - Cameron Simpson <cs@zip.com.au> 21may98 mring: # msgid2dj: #!/bin/sh msgid2dj: # msgid2dj: # Convert msgids into DejaNews thread references. msgid2dj: # Thanks to the Robot Wisdom Weblog msgid2dj: # http://www.robotwisdom.com/ msgid2dj: # - Cameron Simpson <cs@zip.com.au> 02aug99 msgid2dj: # mugshot: #!/bin/sh mugshot: # mvarchive: #!/bin/sh mvarchive: # mvarchive: # Move an archived user from elph to shot via an intermediary mvarchive: # (because we're having weird automounter timeouts on elph at present). mvarchive: # - Cameron Simpson <cs@zip.com.au> 02nov2000 mvarchive: # mvdir: #!/bin/sh mvgroup: #!/bin/sh mvgroup: # mvgroup: # Bulk edit the group file to rename a group. mvgroup: # - Cameron Simpson <cs@zip.com.au> 09mar99 mvgroup: # mvhost: #!/usr/bin/perl mvhost: # mvhost: # Repatch a host. mvhost: # - Cameron Simpson <cs@zip.com.au> 13jul98 mvhost: # mx: #!/bin/sh mx: ## exec nslookup -query=mx ${1+"$@"} mycvs: #!/usr/bin/perl -w mycvs: # mycvs: # CVS mucks file permissions about. Links, too. mycvs: # This stub preserves file permissions. mycvs: # Also does some extra things (ls, check, ...). mycvs: # - Cameron Simpson <cs@zip.com.au> 08apr97 mycvs: # mydb: #!/bin/sh mydb: # mydb: # Fire up a mysqld for a particular dataset. mydb: # - Cameron Simpson <cs@zip.com.au> 02jul99 mydb: # myenv: #!/bin/sh myenv: # myenv: # Wrapper an environment trashing command (like su or ssh) to pass my myenv: # environment through to the far end. Lifted from my su wrapper. myenv: # - Cameron Simpson <cs@zip.com.au> 07feb2002 myenv: # mygcc: #!/bin/sh mygcc: # mykebuild: #!/usr/bin/perl mykebuild: # mykebuild: # Wrapper for myke to build most binaries or libraries. mykebuild: # - Cameron Simpson, 19jul92 mykebuild: # mykebuild: # Translated from SysV shell to Perl. - cameron, 05may93 mykebuild: # mykeshell: #!/bin/sh mymysql: #!/bin/sh mymysql: # mymysql: # Connect to my personal mysql server. mymysql: # - Cameron Simpson <cs@zip.com.au> 27jun2000 mymysql: # mys: #!/bin/sh myzipfat: #!/bin/sh myzipfat: # myzipfat: # Format, mformat, chown etc to make up a FAT filesystem on a Zip disc. myzipfat: # Uses the mtools. myzipfat: # - Cameron Simpson <cs@zip.com.au> 22nov96 myzipfat: # myzipfs: #!/bin/sh myzipfs: # myzipfs: # Format, newfs, chown etc to make up a filesystem on a Zip disc. myzipfs: # - Cameron Simpson <cs@zip.com.au> 22nov96 myzipfs: # nan: #!/bin/sh nbg: #!/bin/sh nbg: # nbg: # Add a file to the not-a-background reject list. nbg: # - Cameron Simpson <cs@zip.com.au> 20nov2000 nbg: # ndx822: #!/usr/bin/perl ndx822: # ndx822: # Adjust the indices associated with archived news/mail items. ndx822: # - Cameron Simpson, cs@zip.com.au, 23jun94 ndx822: # ndx822: # Indices: ndx822: # msgids Msgids present in the archive, forward and backward refs. ndx822: # absent Msgids _not_ present in the archive. ndx822: # ptx' Permuted index. ndx822: # ndxcpio: #!/usr/bin/perl ndxcpio: # ndxcpio: # Read cpio -c from stdin, emit index on stdout. ndxcpio: # - Cameron Simpson, 31dec93 ndxcpio: # necho: #!/bin/sh need-ssh-agent: #!/bin/sh need-ssh-agent: # need-ssh-agent: # Set up ssh authentication. need-ssh-agent: # - Cameron Simpson <cs@zip.com.au> need-ssh-agent: # need-ssh-agent: # Attempt to latch onto existing agent from other session. need-ssh-agent: # - Cameron Simpson <cs@zip.com.au> 22aug2000 need-ssh-agent: # needdir: #!/bin/sh needdir: # needdir: # Require existence of directory, creating it if needed. needdir: # - Cameron Simpson <cs@zip.com.au> 04may2002 needdir: # netfind: #!/bin/sh netgroup: #!/bin/sh netgroup: # netgroup: # Added -r & -R flags. netgroup: # Sent usage to stderr. netgroup: # Hmm, added usage! netgroup: # - cameron 03jun96 netgroup: # netscan: #!/usr/bin/perl netscan: # netscan: # netscan v1.1 - scan a network to identify its active nodes netscan: # netscan: # usage: netscan -n network_addr [-s subnet_mask] [-v] netscan: # netscan: # 20 Mar 1995: v1.0 written by Peter Couvares <pfcouvar@unix.amherst.edu> netscan: # 31 May 1995: v1.1 major fixes/improvements new-ssh-agent: #!/bin/sh new-ssh-agent: # new-ssh-agent: # Toss existing ssh-agent knowledge and start anew. new-ssh-agent: # - Cameron Simpson <cs@zip.com.au> 09may99 new-ssh-agent: # newsfilt: #!/usr/bin/perl newsfilt: # newsfilt: # Autofile my news. - Cameron Simpson <cs@zip.com.au> newsfilt: # newurls: #!/bin/sh nexts: #!/bin/sh nexts: # nexts: # Emit machine list via netgroup. nexts: # - Cameron Simpson <cs@zip.com.au> 24sep96 nexts: # ng2to: #!/bin/sed -nf ng2to: # ng2to: # Create a To: line with ng@usenet for use in mutt. ng2to: # - Cameron Simpson <cs@zip.com.au> 09jun2002 ng2to: # ngr: #!/bin/sh ngr: # ngr: # Sorted tidy recursive netgroup listing. ngr: # - Cameron Simpson <cs@zip.com.au> ngr: # ngssh: #!/bin/sh ngssh: # ngssh: # Bgssh to a netgroup. ngssh: # - Cameron Simpson <cs@zip.com.au> 08feb2001 ngssh: # nicknames: #!/bin/sh nid: #!/bin/sh nisauth: #!/bin/sh nisauth: # nisauth: # Verify authentication using UNIX NIS crypt password. nisauth: # - Cameron Simpson <cs@zip.com.au> 15feb2001 nisauth: # nisauth: # Exit status: nisauth: # 0 Login and password match. nisauth: # 1 Mismatch or lookup failure. nisauth: # 2 Usage (invocation error). nisauth: # nl2indent: #!/usr/bin/perl nl2indent: # nl2indent: # Convert a blank-line separated list of records to a ring-style nl2indent: # leading-non-white delimited list. nl2indent: # - Cameron Simpson <cs@zip.com.au> 29jul96 nl2indent: # nntp: #!/bin/sh no-ssh-agent: #!/bin/sh no-ssh-agent: # no-ssh-agent: # Ssh lacks a methods to restrict what authentication mechanisms no-ssh-agent: # it uses. Hence this hack to at least remove the ssh-agent knowledge no-ssh-agent: # from the environment. no-ssh-agent: # - Cameron Simpson <cs@zip.com.au> 17mar99 no-ssh-agent: # noldpath: #!/bin/sh noldpath: # noldpath: # Strip my LD_LIBRARY_PATH, rely on the system one. noldpath: # - Cameron Simpson <cs@zip.com.au> 20nov99 noldpath: # normal: #!/bin/sh normal: # normal: # Colourise a stream. normal: # - Cameron Simpson <cs@zip.com.au> 06may99 normal: # nospam: #!/usr/bin/perl nospam: # nospam: # Filter spam from a mail feed. nospam: # - Cameron Simpson <cs@zip.com.au> 25jul97 nospam: # not: #!/bin/sh note: #!/bin/sh note: # note: # Stash strings for later. note: # Adapted from noteurl. note: # - Cameron Simpson <cs@zip.com.au> 15nov96 note: # note: # Streamlined the logic. - cameron, 16feb98 note: # Fix race condition on tag existence. - cameron, 14sep98 note: # noteaddrs: #!/bin/sh noteaddrs: # noteaddrs: # Read mail addresses, one per line, and record in raw mailrc db. noteaddrs: # - Cameron Simpson <cs@zip.com.au> 15jun98 noteaddrs: # noteurl: #!/bin/sh noteurl: # noteurl: # Stash a URL for later browsing. noteurl: # - Cameron Simpson <cs@zip.com.au> 15nov96 noteurl: # now: #!/usr/bin/perl now: # nox: #!/bin/sh nphssh: #!/bin/sh nphssh: # nphssh: # Run an ssh with a no-pass-phrase key file. nphssh: # Naturally we supply no command as that should be hardwired nphssh: # at the far end. nphssh: # - Cameron Simpson <cs@zip.com.au> 14jul2001 nphssh: # npic: #!/bin/sh nread: #!/bin/sh nread: # nread: # Read a string with echo turned off. nread: # Echo the string to stdout. nread: # We expect to be called as: nread: # passphrase=`nread prompttstring` nread: # nread: # - Cameron Simpson <cs@zip.com.au> 22oct96 nread: # nread: # set -vx ns: #!/usr/bin/perl ns: # ns2: #!/bin/sh nsbmclean: #!/usr/bin/perl nsbmclean: # nsbmclean: # Demoronize the netscape bookmarks file. nsbmclean: # - Cameron Simpson <cs@zip.com.au> 11mar98 nsbmclean: # nsbmparse: #!/usr/bin/perl nsbmparse: # nsbmparse: # Parse the Netscape bookmark file (post clean by nsbmclean) nsbmparse: # and do things with the structure. nsbmparse: # - Cameron Simpson <cs@zip.com.au> 13mar98 nsbmparse: # nsdlfix: #!/bin/sh nsdlfix: # nsdlfix: # Netscape has an unfortunate tendency to uncompress downloaded nsdlfix: # files and, better still, doesn't strip off the .Z or .gz extension. nsdlfix: # Thus this hack to clean up. nsdlfix: # - Cameron Simpson <cs@zip.com.au> 04dec98 nsdlfix: # nshistparse: #!/usr/bin/perl nshistparse: # nshistparse: # Parse the anchors in the cleaned netscape history dump nshistparse: # and write plain HTML. nshistparse: # - Cameron Simpson <cs@zip.com.au> 13mar98 nshistparse: # nsm68k: #!/bin/sh nsm68k: # nsm68k: # Emit machine list via netgroup. nsm68k: # - Cameron Simpson <cs@zip.com.au> 24sep96 nsm68k: # nsr3p: #!/bin/sh nsr3p: # nsr3p: # Use a 3rd party tape with Legato Networker. nsr3p: # Specificly, we want to make a tape which isn't part of Legato's nsr3p: # indices using a Legato controlled jukebox. nsr3p: # nsr3p: # This is based on suggestions made by Janelle Filkin <janellef@dawn.com.au>. nsr3p: # - Cameron Simpson <cs@zip.com.au> nsr3p: # nsrimport: #!/bin/sh nsrimport: # nsrimport: # Import tapes from the load bay to specified slots. nsrimport: # - Cameron Simpson <cs@zip.com.au> 23oct2000 nsrimport: # nsrswap: #!/usr/bin/perl nsrswap: # nsrswap: # Orchestrate a tape swapout for our jukebox. nsrswap: # - Cameron Simpson <cs@zip.com.au> 24oct2000 nsrswap: # nstest: #!/bin/sh nu: #!/bin/sh nway: #!/bin/sh nway: # nway: # INCOMPLETE nway: # nway: # A sort of inverse of the foreach script. nway: # Foreach takes lines from its input and run a command for each nway: # with an arbitrary degree of parallelism. nway: # This script makes an arbitrary number of instances of a command nway: # and parcels its input out to them a line at a time. nway: # NOTE: this uses lock(1) for the pipe read locking, which is pretty nway: # expensive, so this script is only a win when the work per line of input nway: # is potentially large. Also, because of the pipe between the reader and nway: # the subcommand you need a fair amount of input before things block, nway: # so the "block the expensive branch and let the others flow" isn't as nway: # even as you might hope. But the "let the others flow" half should work fine. nway: # - Cameron Simpson <cs@zip.com.au> 20oct2000 nway: # odiff: #!/bin/sh odiff: # odiff: # Octal diff for binary files with fixed length records. odiff: # - Cameron Simpson <cs@zip.com.au> 01mar95 odiff: # openoffice: #!/bin/sh openoffice: # openoffice: # Wrapper for OpenOffice to make first use painless. openoffice: # Ported from the soffice wrapper. openoffice: # - Cameron Simpson <cs@zip.com.au> 26mar2002 openoffice: # opieauth: #!/bin/sh optusbill: #!/usr/bin/perl optusbill: # other: #!/bin/sh otp: #!/usr/bin/perl otp: # otp: # Connect to the opieauth service and validate things. otp: # otp: # Usage: otp: # otp user Print challenge on stdout. otp: # otp user response Try response, set exit value to success/fail. otp: # otp: # - Cameron Simpson <cs@zip.com.au> 05dec96 otp: # otpadlist: #!/bin/sh otpadlist: # otpadlist: # List the known one time pad URLs. otpadlist: # - Cameron Simpson <cs@zip.com.au> 24jul2000 otpadlist: # otpadsets: #!/bin/sh otpadsets: # otpadsets: # List the otpad sets I know about. otpadsets: # - Cameron Simpson <cs@zip.com.au> 04aug2000 otpadsets: # outmail: #!/bin/sh pageforms: #!/bin/sh pageforms: # pageforms: # Return the FORMs in a web page. pageforms: # - Cameron Simpson <cs@zip.com.au> 03mar99 pageforms: # pageif: #!/bin/sh pageif: # pageif: # Run a command, piping into a pager if stdout is a tty. pageif: # - Cameron Simpson <cs@zip.com.au> 27feb2000 pageif: # pageurls: #!/bin/sh pageurls: # pageurls: # Extract URLs from web pages. Recode after "urls" recode :-( pageurls: # - Cameron Simpson <cs@zip.com.au> 25aug2000 pageurls: # parsesyslog: #!/usr/bin/perl parsesyslog: # pcol: #!/bin/sh pcol: # pcol: # Print selected columns with awk. pcol: # Accepts -Fc for field separator. pcol: # - Cameron Simpson <cs@zip.com.au> 24aug99 pcol: # pcs: #!/bin/sh pcs: # pcs: # Emit machine list via netgroup. pcs: # - Cameron Simpson <cs@zip.com.au> 24sep96 pcs: # pcsharelist: #!/bin/sh pcsharelist: # pcsharelist: # Generate list of Disk shares. pcsharelist: # - Cameron Simpson <cs@zip.com.au> 04nov98 pcsharelist: # pdb: #!/usr/bin/perl pdb: # pdb: # Do things to Palm Pilot PDB files. pdb: # - Cameron Simpson <cs@zip.com.au> 22may2000 pdb: # pdf2ps: #!/bin/sh pdf2ps: # pdf2ps: # Use acroread to convert PDF to PostScript (oh for PDF to HTML!). pdf2ps: # - Cameron Simpson <cs@zip.com.au> 14may1997 pdf2ps: # pdf2ps: # No, acroread doesn't parse command line options like most UNIX pdf2ps: # filters, hence the cat prefix. pdf2ps: # No, you can't use -xrm to control things if you don't run pdf2ps: # interactively, hence the juggling of .acrorcs. pdf2ps: # No, the Level-1 option is a no-op on a Level-2 printer, hence the pdf2ps: # override of "Level2?". pdf2ps: # Yes, there's something odd about the halftoning, not sure what yet. pdf2ps: # pdlog: #!/bin/sh perldeps: #!/usr/bin/perl perldeps: # perldeps: # Print out the list of files `use'd by a perl program for bundling perldeps: # things up. perldeps: # - Cameron Simpson <cs@zip.com.au> 05mar1997 perldeps: # perlinst: #!/bin/sh perlinst: # perlinst: # Install a perl module. perlinst: # - Cameron Simpson <cs@zip.com.au> 01jun99 perlinst: # perlkit: #!/bin/sh perlkit: # perlkit: # Emit a tar archive of the named scripts and their dependent cs:: modules. perlkit: # - Cameron Simpson <cs@zip.com.au> 02sep98 perlkit: # perlstrs: #!/usr/bin/perl perlstrs: # perlstrs: # Tired of fighting with broken echo commands which interpret -n perlstrs: # or cs@zip.com.au etc, I resort to this cumbersome wrapper for the common perlstrs: # blah=`echo "$blah" | sed 's/this/that/g'` perlstrs: # thing. perlstrs: # Based on sedstrs, which doesn't do newlines. perlstrs: # - Cameron Simpson <cs@zip.com.au> 25aug97 perlstrs: # perror: #!/bin/sh pgpedit: #!/bin/sh pgpedit: # pgpedit: # Edit a PGP encrypted file. Extracted from "edit". pgpedit: # - Cameron Simpson <cs@zip.com.au> pgpedit: # pgpem: #!/bin/sh pgpem: # pgpfwd: #!/usr/bin/perl pgpfwd: # pgpfwd: # Forwarder for auto-PGP-encryption mail aliases. pgpfwd: # Simple rip off of exfwd. pgpfwd: # - Cameron Simpson <cs@zip.com.au> 08jun2000 pgpfwd: # pgpmailitem: #!/bin/sh pgpmailitem: # pgpmailitem: # PGP encrypt the body of a mail message from stdin. pgpmailitem: # - Cameron Simpson <cs@zip.com.au> 08apr97 pgpmailitem: # ph: #!/bin/sh phash: #!/usr/bin/perl -w phash: # phash: # Set or report data from a persistent object. phash: # Based on the old user script. phash: # - Cameron Simpson <cs@zip.com.au> 10apr97 phash: # phdb2txt: #!/usr/bin/perl phdb2txt: # phdb2txt: # Dump my phone DB into flat text. phdb2txt: # - Cameron Simpson <cs@zip.com.au> phdb2txt: # phone: #!/bin/sh phone: # phone: # Complete rewrite by Cameron. phone: # Moved much stuff into user db. - cameron 20nov97 phone: # phonesummary: #!/usr/bin/perl phonesummary: # phonesummary: # Emit .csv data for phone info. phonesummary: # - Cameron Simpson <cs@zip.com.au> 22feb2000 phonesummary: # phref: #!/bin/sh phref: # pickn: #!/bin/sh pickn: # pickn: # Pick some lines at random from the input, by default 1. pickn: # - Cameron Simpson <cs@zip.com.au> 19jul2000 pickn: # pickn: # Pattern match for selection. - cameron 12sep2000 pickn: # Treat all args as regexps to AND. - cameron, 12nov2001 pickn: # pickotpads: #!/bin/sh pickotpads: # pickotpads: # Pick some random pads from those available on the net. pickotpads: # - Cameron Simpson <cs@zip.com.au> 24jul2000 pickotpads: # picksig: #!/usr/bin/perl picksig: # picksig: # Print a random signature. picksig: # The file has the format picksig: # -- [keywords] picksig: # sig, may be multiple lines picksig: # picksig: # - Cameron Simpson, March 1993 picksig: # pilfer: #!/bin/sh pilfer: # pilfer: # Rummage through a web page pulling out the items of interest. pilfer: # - Cameron Simpson <cs@zip.com.au> 19jun99 pilfer: # pilfer: # Input format: pilfer: # TITLE title Output TITLE tag. Should come early. pilfer: # URL [-i] title Page to pilfer. -i gets inline refs. pilfer: # Make an H1 heading with the title. pilfer: # Hn heading Category heading. pilfer: # LI ptn Rexgexp for URLs, implicitly anchored at ^. pilfer: # ! command Run shell command with the current page URL pilfer: # appended and with the page URLs on stdin; pilfer: # replace URL list with output. pilfer: # # pipeargs - feed arguments, one per line, to stdin of a command pipeto: #!/bin/sh pipeto: # pipeto: # Attach a command to a named pipe so that other things can pipe info pipeto: # to it with abandon. pipeto: # - Cameron Simpson <cs@zip.com.au> 16dec93 pipeto: # pipeto: # Recode to be more generic. - cameron, 18jul94 pipeto: # pline: #!/bin/sh pman: #!/bin/sh pndx: #!/usr/bin/perl pndx: # pndx: # Permuted index, after ptx. pndx: # - Cameron Simpson <cs@zip.com.au> 05may97 pndx: # pndx: # Input: pndx: # ref line of text pndx: # Output: pndx: # ref TAB left-words TAB keyword TAB right-words pndx: # pndx2html: #!/usr/bin/perl pndx2html: # pndx2html: # Convert pndx output to HTML. pndx2html: # - Cameron Simpson <cs@zip.com.au> 06may97 pndx2html: # popSHELL: #!/bin/sh popSHELL: # popSHELL: # Restore $SHELL from saved setting then exec $popSHELLexec. popSHELL: # This is really an ugly hack to get the script(1) command popSHELL: # to run something arbitrary rather than the user's shell popSHELL: # since for some unknown reason is just execs $SHELL. popSHELL: # Sad but true. Hence this script. popSHELL: # - Cameron Simpson <cs@zip.com.au> 18may2002 popSHELL: # portfwd: #!/bin/sh portfwd: # portfwd: # Arrange forwarding of the usual ports. portfwd: # - Cameron Simpson <cs@zip.com.au> 15apr1999 portfwd: # pphtml: #!/usr/bin/perl pphtml: # pphtml: # Read HTML and rewrite it nicely indented. pphtml: # Based on htparse, the debugging script. pphtml: # - Cameron Simpson, cs@zip.com.au, 15jun94 pphtml: # pptx: #!/usr/bin/perl pptx: # pptx: # Generate a permuted index. pptx: # prat: #!/bin/sh prat: # prat: # Invoke munpack with some default options for easy invocation. prat: # - Cameron Simpson <cs@zip.com.au> 24dec96 prat: # prci: #!/bin/sh prefetch: #!/bin/sh prefetch: # prefetch: # Prefetch web pages so they're in the proxy cache. prefetch: # - Cameron Simpson <cs@zip.com.au> 19mar99 prefetch: # prfc: #!/bin/sh pri: #!/bin/sh pri: # pri: # Term with private env. pri: # - Cameron Simpson <cs@zip.com.au> 10may99 pri: # pring: #!/bin/sh printf: #!/usr/bin/perl prog: #!/bin/sh prog: # prog: # Query archie via email. prog: # proj - manipulate the timesheets database proxy_redir: #!/usr/bin/perl proxy_redir: # proxy_redir: # Redirect all requests to a given URL. proxy_redir: # Once used by the ad zapping proxy.pac. proxy_redir: # - Cameron Simpson <cs@zip.com.au> 31jul97 proxy_redir: # proxyhtclean: #!/usr/bin/perl proxyhtclean: # proxyhtclean: # ps2ascii: #!/bin/sh ps2ascii: # ps2ascii: # Cleaner version of the scripts supplied with ghostscript. ps2ascii: # - Cameron Simpson <cs@zip.com.au> 07may97 ps2ascii: # ps_ppid: #!/bin/sh ps_ppid: # psa: #!/bin/sh pshuf: #!/usr/bin/perl pshuf: # pshuf: # Shuffle and select pages of well-formed PostScript. pshuf: # - Cameron Simpson, February 1992 pshuf: # pshuf: # Notes: pshuf: # The select range selects on the input physical pages, but the -r and pshuf: # -num,... options apply before pages are rejected by the selector. pshuf: # pshuf: # Ditroff/psdit output defines the font select operators at their pshuf: # first use, so if you select pages with pshuf rather than through the pshuf: # -o option to troff you probably need to select the first physical pshuf: # page in addition to the desired pages. Locate the pattern: pshuf: # ^/f\..*def$ pshuf: # in the PostScript output. I could, I guess, add a hack to grab these pshuf: # and move them into the Prolog, but jeez... pshuf: # psl: #!/bin/sh psquid: #!/bin/sh psrot: #!/bin/sh psrot: # psu: #!/bin/sh pt - print process tree ptail: #!/usr/bin/perl ptail: # ptail: # Return the last N lines of the input. ptail: # Stock tail commands seem to have buffer limitations. ptail: # - Cameron Simpson <cs@zip.com.au> 20nov98 ptail: # ptroff: #!/bin/sh pui: #!/bin/sh pushttylabel: #!/bin/sh pushttylabel: # pushttylabel: # Label the tty for the duration of a command, then restore. pushttylabel: # - Cameron Simpson <cs@zip.com.au> 25dec1999 pushttylabel: # pushttylabel: # Add -a to append to existing label. - cameron 23mar2000 pushttylabel: # Make -a the default. - cameron 12apr2000 pushttylabel: # putcgi: #!/bin/sh putcgi: # putcgi: # CGI script to PUT files for publishing tools. putcgi: # - Cameron Simpson <cs@zip.com.au> 16feb2001 putcgi: # pw: #!/bin/sh pw: # pw: # Wrapper for pwcrypt to set UNIX password hash. pw: # - Cameron Simpson <cs@zip.com.au> 27may99 pw: # pwcrypt: #!/usr/bin/perl pwcrypt: # pwcrypt: # Generate a passwd-style encryption for the input. pwcrypt: # - Cameron Simpson <cs@zip.com.au> 07mar97 pwcrypt: # pxauth: #!/bin/sh pxauth: # pxauth: # Print xauth info for piping into "gxauth -". pxauth: # - Cameron Simpson, 20jun94 pxauth: # qcmd: #!/usr/bin/perl qcmd: # qcmd: # Run a command with its final arguments concatenated into a single qcmd: # that the shell will decouple into the original argument list. qcmd: # This is intended for passing arguments lists via commands like qcmd: # ssh and its predecessor rsh, which join their arguments with qcmd: # spaces. qcmd: # qcmd: # Example: qcmd: # qcmd -1 ssh xo:fnt -o foo -t host command 'arg with spaces' qcmd: # - Cameron Simpson <cs@zip.com.au> 22apr2001 qcmd: # qdlog: #!/bin/sh qenvssh: #!/bin/sh qsencode: #!/bin/sh qsencode: # qsencode: # Encode a string for use in a URL's QUERY_STRING. qsencode: # - Cameron Simpson <cs@zip.com.au> 30apr2002 qsencode: # qssh: #!/bin/sh qssh: # qssh: # Ssh for a single command, preserving arguments. qssh: # - Cameron Simpson <cs@zip.com.au> 22apr2001 qssh: # que: #!/bin/sh query2url: #!/usr/bin/perl query2url: # query2url: # Emit a GET URL embodying the specified query. query2url: # - Cameron Simpson <cs@zip.com.au> 17may97 query2url: # query_string2sh: #!/bin/sh query_string2sh: # query_string2sh: # Take argument as a $QUERY_STRING CGI parameter and emit shell to query_string2sh: # turn the values into PARAM_x for each parameter x. query_string2sh: # - Cameron Simpson <cs@zip.com.au> 11aug1999 query_string2sh: # query_string2sh: # Use $QUERY_STRING itself if no arg. query_string2sh: # quoted-printable: #!/usr/bin/perl quoted-printable: # quoted-printable: # Encode data in quoted=-printable format.. quoted-printable: # Very quick'n'dirty. Should really stream for large input. quoted-printable: # - Cameron Simpson <cs@zip.com.au> 27aug2001 quoted-printable: # # rab - remote histbackup rawhtv: #!/bin/sh rawmaildrop: #!/bin/sh rawmaildrop: # rbg: #!/bin/sh rbg: # rbg: # Run rootbg then clear my alert window. rbg: # - Cameron Simpson <cs@zip.com.au> 17nov2001 rbg: # rcf: #!/bin/sh rcf: # rcf: # Do a remote conform. - Cameron Simpson, 11nov93 rcf: # rcphome: #!/bin/sh rcphome: # rdiff: #!/bin/sh rdiff: # rdiff: # List recursive diff of two dirs with some noise chopped. rdiff: # - Cameron Simpson <cs@zip.com.au> 22nov98 rdiff: # readdottext: #!/bin/sh readdottext: # readdottext: # Prompt for text (typically a change description). readdottext: # - Cameron Simpson <cs@zip.com.au> 23dec99 readdottext: # readsymlink: #!/usr/bin/perl readsymlink: # readsymlink: # Return the contents of a symlink. readsymlink: # - Cameron Simpson <cs@zip.com.au> 04dec2000 readsymlink: # recipe2html: #!/usr/bin/perl recipe2html: # recipe2html: # Convert mod.recipes/alt.gourmand recipes source to HTML. recipe2html: # - Cameron Simpson <cs@zip.com.au> 17may95 recipe2html: # remind: #!/usr/bin/perl remind: # remind: # Remind/memo replacement. - Cameron 10mar94 remind: # rename: #!/usr/bin/perl replace: #!/bin/sh replace: # replace: # Replace text between two lines denoted by regexps. replace: # - Cameron Simpson <cs@zip.com.au> 20sep95 replace: # reslist: #!/bin/sh reslist: # reslist: # Extract X resource names. reslist: # - Cameron Simpson <cs@zip.com.au> 22oct96 reslist: # respam: #!/bin/sh respam: # respam: # Forward the input n times to the given addresses. respam: # Used to send spam back to the orginator. respam: # To be used _only_ when completely sure of the originator's email address. respam: # - Cameron Simpson <cs@zip.com.au> respam: # revecho: #!/bin/sh revndx: #!/bin/sh revndx: # revndx: # Recurse down a directory tree containing event data. revndx: # Emit an HTML listing if the tree. revndx: # - Cameron Simpson <cs@zip.com.au> 05jan98 revndx: # rewriteif: #!/bin/sh rewriteif: # rewriteif: # Rewrite the named file if the input differs. rewriteif: # - Cameron Simpson <cs@zip.com.au> 19may2000 rewriteif: # rfc: #!/bin/sh rfc: # rfc: # Pop up an RFC. rfc: # - Cameron Simpson <cs@zip.com.au> 05nov1996 rfc: # rg: #!/bin/sh rg: # rg: # Recursive "g". rg: # - Cameron Simpson <cs@zip.com.au> 07aug2001 rg: # rglob: #!/bin/sh rig-ssh-agent: #!/bin/sh rig-ssh-agent: # rig-ssh-agent: # Set up an ssh-agent in daemon mode. rig-ssh-agent: # - Cameron Simpson <cs@zip.com.au> 30jul2001 rig-ssh-agent: # rigPATH: #!/bin/sh rigSOURCE_DISPLAY: #!/bin/sh rigSOURCE_DISPLAY: # - Cameron Simpson <cs@zip.com.au> 22mar2001 rigapollo: #!/bin/sh rigapollo: # was tpm -r -s 10000 10000 rigbin: #!/bin/sh rigconsole: #!/bin/sh rigconsole: # rigconsole: # Start an xterm_console if one's not already active. rigconsole: # - Cameron Simpson <cs@zip.com.au> 05may99 rigconsole: # rigconsolelog: #!/bin/sh rigconsolelog: # rigconsolelog: # Run console monitor on current display. rigconsolelog: # - Cameron Simpson <cs@zip.com.au> 05may99 rigconsolelog: # rigdir: #!/usr/bin/perl rigdir: # rigdir: # Mimic transparent multiple directory mounts through cunning use rigdir: # of link and symlink. rigdir: # - Cameron Simpson, 04dec92 rigdir: # rigfilemail: #!/bin/sh rigfilemail: # set up the mail/news autofiler rigfreenet: #!/bin/sh rigfreenet: # rigfreenet: # Set up my freenet server. rigfreenet: # Current is test mode, so no advertising. rigfreenet: # - Cameron Simpson <cs@zip.com.au> 29dec2000 rigfreenet: # rigftp: #!/bin/sh rigftp: # rigftp: # Consult my .ftprc file and construct my ftp directory. rigftp: # rigfvwmevlog: #!/bin/sh rigjuke: #!/bin/sh rigloadmeters: #!/bin/sh rigloadmeters: # rigloadmeters: # Instantiatie the usual load meters. rigloadmeters: # - Cameron Simpson <cs@zip.com.au> rigloadmeters: # rigman: #!/bin/sh rigmodem: #!/bin/sh rigmodem: # rigmodem: # Usage: rigmodem [-line n] [targets...] rigmodem: # rigmodem: # Expects to be used as "~$rigmodem [targets...]" from inside tip. rigmodem: # rigmotion: #!/bin/sh rigmotion: # rigmotion: # File up motion setings output the log file. rigmotion: # - Cameron Simpson <cs@zip.com.au> 27jan2002 rigmotion: # rigmydb: #!/bin/sh rignntpcache: #!/bin/sh rigrxvtbg: #!/bin/sh rigrxvtbg: # rigrxvtbg: # Regularly run setrxvtbg in the background. rigrxvtbg: # - Cameron Simpson <cs@zip.com.au> 31aug2000 rigrxvtbg: # rigsquid: #!/bin/sh rigsquid: # rigsquid: # Start up the ad-zapping squid. rigsquid: # - Cameron Simpson <cs@zip.com.au> 17sep1999 rigsquid: # rigstubs: #!/bin/sh rigvnc: #!/bin/sh rigxauth: #!/bin/sh rigxauth: # rigxauth: # Set up xauth for this display, then copy it to our base homes. rigxauth: # - Cameron Simpson, 01aug92 rigxauth: # rigxmodmap: #!/bin/sh rigxmodmap: # rigxmodmap: # Make the keyboard more sane. rigxmodmap: # - Cameron Simpson <cs@zip.com.au> 14apr2000 rigxmodmap: # rigxmodmap: # Shuffle the keyboard a bit. rigxv: #!/bin/sh ring: #!/usr/bin/perl -w ring: # ring: # Usage: ring [-a] [-f file]... patterns... ring: # ring: # Look up phone lists. Each entry has a non-blank in column one. ring: # - Cameron Simpson ring: # rl: #!/bin/sh rmafter: #!/bin/sh rmafter: # rmafter: # Run a command and remove a file afterwards. rmafter: # - Cameron Simpson <cs@zip.com.au> 18feb2002 rmafter: # rmbg: #!/bin/sh rmbg: # rmbg: # Remove a background image altogether. rmbg: # See also nbg and bglist. rmbg: # - Cameron Simpson <cs@zip.com.au> rmbg: # rmleafdirs: #!/bin/sh rmleafdirs: # rmleafdirs: # Clean out empty directories. rmleafdirs: # - Cameron Simpson <cs@zip.com.au> 10apr2000 rmleafdirs: # rmmjuser: #!/bin/sh rmmjuser: # rmmjuser: # Remove a user from the majordomo lists. rmmjuser: # rmr: #!/bin/sh rmuser: #!/bin/sh rmuser: # rmuser: # Disable user account. rmuser: # Should run on the yp master. rmuser: # - Cameron Simpson <cs@zip.com.au> 12nov96 rmuser: # rollmail: #!/bin/sh rollmail: # rollmail: # Bundle up files in a mail spool. rollmail: # - Cameron Simpson <cs@zip.com.au> 11feb1998 rollmail: # rollmail: # Use catmaildir and gzip instead of tar. - cameron 27mar2000 rollmail: # root@: #!/bin/sh root@: # root@: # Make/attach a logged screened root session on a host. root@: # - Cameron Simpson <cs@zip.com.au> 20may2002 root@: # rootbg: #!/bin/sh rootbg: # rootbg: # Set the root backdrop. rootbg: # - Cameron Simpson <cs@zip.com.au> 20nov2000 rootbg: # rootbg: # -xpl for xplanet support - cameron 30nov2000 rootbg: # rootenv: #!/bin/sh rootenv: # rootenv: # Adopt a rootlike environment. rootenv: # - Cameron Simpson <cs@zip.com.au> 07nov2000 rootenv: # rot13: #!/usr/bin/perl -p routers: #!/bin/sh routers: # routers: # Emit machine list via netgroup. routers: # - Cameron Simpson <cs@zip.com.au> 24sep96 routers: # rpms: #!/bin/bash rpms: # rpms: # Install date of all RPMs most recent first. rpms: # Script courtesy of Aaron Konstam <akonstam@trinity.edu> rpms: # rpmsize: #!/bin/sh rpmsize: # rpmsize: # Report the size of the installed files associated with an RPM. rpmsize: # - Cameron Simpson <cs@zip.com.au> 07apr2002 rpmsize: # rrsync: #!/bin/sh # rsmirror - maintain a local mirror of portions of rsync servers rst2fh: #!/usr/bin/perl rst2fh: # rst2fh: # Nab header and then feed rest to "restore tf -" and parse the output, rst2fh: # emitting stuff for the budtool file history. rst2fh: # - Cameron Simpson <cs@zip.com.au> 24sep96 rst2fh: # rsync_rsh: #!/bin/sh rterm: #!/bin/sh rterm: # rterm: # Quick attach to remote host. rterm: # - Cameron Simpson <cs@zip.com.au> rterm: # rtoc: #!/bin/sh rtoc: # rtoc: # Recursively list tar files. rtoc: # Coded up for Loren Hobbs <loren.hobbs@philips.com>. rtoc: # Returns my "mkdirn" and "t" scripts (and "x", a symlink to "t"). rtoc: # - Cameron Simpson <cs@zip.com.au> 30mar2001 rtoc: # rtop: #!/bin/sh runlevel: #!/bin/sh runlevel: # runlevel: # Transition from current run-level to a new one. runlevel: # runlevel: # This accomodates both the traditional rc.d scheme with runlevel: # its rcN.d/[SK]nnSERVICE files and my preferred scheme runlevel: # with rcN.d/nnSERVICE files. runlevel: # The content of these latter are exactly as for the former, runlevel: # but require only a single link in each runlevel rcN.d directory. runlevel: # In the former scheme you place an S file in the runlevel where runlevel: # a service is active, and a K file in every runlevel where the runlevel: # service is not active. Ugly. runlevel: # In the latter scheme, this script stops the service when you runlevel: # leave the runlevel it was started in. While this is cleaner and simpler, runlevel: # it is necessary to know the relationships between the runlevels, runlevel: # which are not simple ordered values. runlevel: # For the sake of simplicity, we assume S == 1 and that unless specified runlevel: # that any numeric value implies the lower ones. runlevel: # - Cameron Simpson <cs@zip.com.au> 10apr99 # runmaint - run a maintenance script runoff: #!/bin/sh rxt: #!/bin/sh rxt: # rxvtbglog: #!/bin/sh sbg: #!/bin/sh scr: #!/bin/sh scr: # scr: # Simple wrapper for screen. scr: # - Cameron Simpson <cs@zip.com.au> 16apr2002 scr: # scrif: #!/bin/sh scrif: # scrif: # Attach to specified screen or make new one of specified name. scrif: # - Cameron Simpson <cs@zip.com.au> 18may2002 scrif: # search: #!/bin/sh search: # search: # Search a web index via my multiway CGI script. search: # - Cameron Simpson <cs@zip.com.au> 10may1997 search: # secret: #!/usr/bin/perl secret: # secret: # Fetch or secrete a secret. secret: # - Cameron Simpson <cs@zip.com.au> 09nov1999 secret: # sedstrs: #!/usr/bin/perl sedstrs: # sedstrs: # Tired of fighting with broken echo commands which interpret -n sedstrs: # or cs@zip.com.au etc, I resort to this cumbersome wrapper for the common sedstrs: # blah=`echo "$blah" | sed 's/this/that/g'` sedstrs: # thing. sedstrs: # - Cameron Simpson <cs@zip.com.au> 25aug97 sedstrs: # sendmail: #!/bin/sh sendmesg: #!/usr/bin/perl -w sendmesg: # sendmesg: # Acts like sendmail but intercepts messages to newsgroup@usenet and sendmesg: # dispatches then via NNTP, suitably rewritten. Addresses come on the sendmesg: # command line. sendmesg: # - Cameron Simpson <cs@zip.com.au> 08jun2002 sendmesg: # set-x: #!/bin/sh -x setbg: #!/bin/sh setbg: # setbg: # Set my screen backdrop. setbg: # - Cameron Simpson <cs@zip.com.au> 19may99 setbg: # # setperms - set permissions on files setrxvtbg: #!/bin/sh setrxvtbg: # setrxvtbg: # Create a temporary xpm file and set the background of an rxvt. setrxvtbg: # - Cameron Simpson <cs@zip.com.au> 31aug2000 setrxvtbg: # setrxvtbg: # exit 0 ## for a moment setvar: #!/usr/bin/perl setvar: # setvar: # Script to compute various environment parameters. setvar: # Must be sourced, and defines the shell function setvar() as a consequence. setvar: # - Cameron Simpson, 18may93 setvar: # setvar: # Removed -n option. setvar: # Recoded not to recurse to bypass Sys5 shell braindamage. - cameron, 30jul93 setvar: # Recoded in Perl to bypass more shell braindamage. setvar: # You don't source it anymore. - cameron, 07jan94 setvar: # Added -f to force resetting variables. - cameron, 11jan94 setvar: # Generalisation. - cameron, 02dec98 setvar: # sgparse: #!/usr/bin/perl sgparse: # sgparse: # Extract tokens from SGML. sgparse: # - Cameron Simpson <cs@zip.com.au> 26oct99 sgparse: # sh-users: #!/bin/sh sh-users: # sh-users: # List the users with a particular shell. sh-users: # - Cameron Simpson <cs@zip.com.au> 30sep96 sh-users: # sh-x: #!/bin/sh shc: #!/bin/sh shc: # shc: # Run a command with $1, $2 etc set up. shc: # - Cameron Simpson <cs@zip.com.au>, 04oct94 shc: # shell: #!/bin/sh shell: # shell: # General wrapper for various shells to tweak SHELL to match. shell: # - Cameron Simpson <cs@zip.com.au> 28feb99 shell: # showface: #! /bin/sh showface: # showface: # Receive a message with an X-Face: header on stdin and display it. showface: # - John Kodis <kodis@jagunet.com> showface: # showpageurls: #!/bin/sh showpageurls: # showtxturls: #!/bin/sh shqstr: #!/usr/bin/perl shqstr: # shqstr: # Emit the arguments suitably quoted for passing via the shell. shqstr: # - Cameron Simpson <cs@zip.com.au> 22apr2001 shqstr: # shuffle: #!/usr/bin/perl shuffle: # shuffle: # Reorder the input lines at random. shuffle: # (I really think seq(1) should have a -r to make a random sequence, shuffle: # but apparently not). shuffle: # - Cameron Simpson <cs@zip.com.au> 14jul2000 shuffle: # shx: #!/bin/sh shx: # shx: # Coloured tracing sh. shx: # - Cameron Simpson <cs@zip.com.au> 25jul99 shx: # si: #!/bin/sh si: # sig: #!/bin/sh signal: #!/bin/sh sitecount: #!/bin/sh sitecount: # sitecount: # Read squid log data from stdin and write the host component to stdout with sitecount: # hit counts. sitecount: # - Cameron Simpson <cs@zip.com.au> 11oct2000 sitecount: # sitemaint: #!/bin/sh sitemaint: # sl: #!/usr/bin/perl sl: # sl: # Walk path reporting symlinks. sl: # - Cameron Simpson <cs@zip.com.au> 07may97 sl: # slcs: #!/bin/sh slcs: # slcs: # Emit machine list via netgroup. slcs: # - Cameron Simpson <cs@zip.com.au> 24sep96 slcs: # sm: #!/bin/sh sm: # sm: # Short message. sm: # - Cameron Simpson <cs@zip.com.au> 16aug96 sm: # smail: #!/bin/sh smail: # smail: # Usage: smail addresses... < complete-message smail: # smail: # Dispatch complete message to addresses. smail: # sms: #!/bin/sh sms: # sms: # Dispatch stdin to the named phone numbers. sms: # - Cameron Simpson <cs@zip.com.au> 30jun1997 sms: # smswho: #!/bin/sh smswho: # smswho: # Dispatch short message to known recipient. smswho: # - Cameron Simpson <cs@zip.com.au> 30jun1997 smswho: # smtp: #!/bin/sh smtpsend: #!/usr/bin/perl smtpsend: # smtpsend: # Dispatch email with SMTP. smtpsend: # - Cameron Simpson <cs@zip.com.au> 4aug2000 smtpsend: # sn: #!/bin/sh sn4: #!/bin/sh snap: #!/bin/sh snap: # snap: # Use buff, chkfiles and updfiles to make a cpio file of stuff to snap: # copy to a remote site. snap: # - Cameron Simpson <cs@zip.com.au> 17sep96 snap: # snap-chkfiles: #!/usr/bin/perl snap-chkfiles: # snap-chkfiles: # Examine a list of files to see which have changed. snap-chkfiles: # - Cameron Simpson <cs@zip.com.au> 24aug96 snap-chkfiles: # snapshot: #!/bin/sh snapshot: # snapshot: # Generate a snapshot of the new files in a distribution. snapshot: # Uses chkfiles to track state. Writes a cpio file of the new files. snapshot: # - Cameron Simpson <cs@zip.com.au> 01sep96 snapshot: # snarfaddrs: #!/usr/bin/perl snarfaddrs: # snarfaddrs: # Grab addrs.new and incorporate it into addrs.all. snarfaddrs: # - Cameron Simpson <cs@zip.com.au> 31jan2002 snarfaddrs: # snarfbookmarks: #!/bin/sh snarfbookmarks: # snarfbookmarks: # Squirrel away a copy of my live bookmarks. snarfbookmarks: # - Cameron Simpson <cs@zip.com.au> 05oct99 snarfbookmarks: # snooplogtally: #!/usr/bin/perl snooplogtally: # snooplogtally: # Parse snoopstats logs and graph. snooplogtally: # - Cameron Simpson <cs@zip.com.au> 19nov98 snooplogtally: # snoopstats: #!/bin/sh snoopstats: # snoopstats: # Simple wrapper for snoop to parse the packet info. snoopstats: # Originally written to measure X11 or ssh traffic for a cable modem snoopstats: # feasibility estimate. snoopstats: # - Cameron Simpson <cs@zip.com.au> 14jan99 snoopstats: # sockslog: #!/bin/sh sockslog: # sockslog: # Read sockslog: # start duration bytesin TOPORT bytesout FROMHOST TOHOST FROMPORT \\ sockslog: # FROMHOST:FROMPORT TOHOST:TOPORT sockslog: # from stdin and make graphs. sockslog: # - Cameron Simpson <cs@zip.com.au> 06aug99 sockslog: # sockslog2generic: #!/usr/bin/perl sockslog2generic: # sockslog2generic: # Parse SOCKS logs and emit data suitable for use by logtally. sockslog2generic: # - Cameron Simpson <cs@zip.com.au> 06aug99 sockslog2generic: # soelim: #!/usr/bin/perl soelim: # soelim: # Replacement for the usual soelim program. soelim: # Handles relative .sos properly, compressed files etc. soelim: # - Cameron Simpson <cs@zip.com.au> soelim: # soffice: #!/bin/sh soffice: # soffice: # Wrapper for Star Office to make first use painless. soffice: # - Cameron Simpson <cs@zip.com.au> 11aug2000 soffice: # sortcol: #!/usr/bin/perl sortcol: # sortcol: # Read a titled listing (such as from ps) from stdin and sort on the named sortcol: # columns. Functions by translating column names into sort(1) arguments and sortcol: # passing the header line through direct. sortcol: # - Cameron Simpson <cs@zip.com.au> 28sep2000 sortcol: # sortgroup: #!/usr/bin/perl sortgroup: # sortgroup: # Read UNIX group file, emit in gid order with group members sorted. sortgroup: # - Cameron Simpson <cs@zip.com.au> 12dec97 sortgroup: # sortlen: #!/bin/sh sortlen: # sortlen: # Sort on line length. sortlen: # - Cameron Simpson <cs@zip.com.au> 12jan2001 sortlen: # sp_: #!/bin/sh sp_: # sp_: # Replace whitespace with underscores. sp_: # Can't actually remember why I needed this... :-( sp_: # - Cameron Simpson <cs@zip.com.au> 22apr2001 sp_: # splitmail: #!/usr/bin/perl splitmail: # splitmail: # Split up an ordinary mailbox (From_ separated). splitmail: # If a mailbox is specified, uses filemail to deposit the mail. splitmail: # If a pipeline is specified, pipes each item to that command (eg "|bgprocmail"). splitmail: # Otherwise unpacks into the current directory. splitmail: # - Cameron Simpson, February 1992 splitmail: # splitmail: # Support "| command" in place of mailbox. splitmail: # - Cameron Simpson <cs@zip.com.au> 12jun2001 splitmail: # spu: #!/bin/sh sqlclean: #!/usr/bin/perl -pe sqlclean: # sqlclean: # Embed newlines in MySQL database dumps, for diffing. sqlclean: # - Cameron Simpson <cs@zip.com.au> 24nov99 sqlclean: # squashblanks: #!/usr/bin/perl squashblanks: # squashblanks: # Coalesce adjacent blank lines. Detab. Strip trailing whitespace. squashblanks: # Nothing that tohers haven't done before me. Just can't find it. squashblanks: # - Cameron Simpson <cs@zip.com.au> 09may2002 squashblanks: # squashblanks: # Add skipheaders and outputfilter. - cameron 15may2002 squashblanks: # squid_redirect: #!/usr/bin/perl squid_redirect: # squid_redirect: # See the home page at: squid_redirect: # http://www.zip.com.au/~cs/adzap/index.html squid_redirect: # squid_redirect: # Recode of the ad-zapper in perl. squid_redirect: # Only necessary because the shell seems to be failing big case statements. squid_redirect: # However, things are neater this way anyway because perl will build squid_redirect: # big, optimised, pattern matches. squid_redirect: # - Cameron Simpson <cs@zip.com.au> 09apr99 squid_redirect: # squid_redirect: # Tunable policy by setting $STUBURL_xx to PASS. squid_redirect: # - Cameron Simpson <cs@zip.com.au> 28jul99 squid_redirect: # squid_redirect: # Tunable CLEAR/VISIBLE mode by setting ZAP_MODE. squid_redirect: # - Cameron Simpson <cs@zip.com.au> 26feb2000 squid_redirect: # squid_redirect: # Personal zap pattern support. squid_redirect: # - Cameron Simpson <cs@zip.com.au> 05mar2000 squid_redirect: # squidlog: #!/bin/sh squidlog: # squidlog: # Fetch the last n lines from both proxy logs and collate. squidlog: # - Cameron Simpson <cs@zip.com.au> 20nov98 squidlog: # squidlog2generic: #!/usr/bin/perl squidlog2generic: # squidlog2generic: # Parse squid logs and emit data suitable for use by logtally. squidlog2generic: # - Cameron Simpson <cs@zip.com.au> 26mar99 squidlog2generic: # squidlogtally: #!/usr/bin/perl squidlogtally: # squidlogtally: # Parse squid logs and do cool things, like graph bandwidth etc. squidlogtally: # - Cameron Simpson <cs@zip.com.au> 19nov98 squidlogtally: # ssh-agent-none: #!/bin/sh sshp1: #!/bin/sh stash-ssh: #!/bin/sh stash-xrdb: #!/bin/sh stash-xrdb: # stash-xrdb: # Suck the screen X resources out into the filesystem. Called by rterm. stash-xrdb: # - Cameron Simpson <cs@zip.com.au> 26nov2001 stash-xrdb: # stashcvs: #!/bin/sh stashcvs: # stashcvs: # Snapshot my cvs archive. - Cameron Simpson <cs@zip.com.au> 18may1997 stashcvs: # stashenv: #!/usr/bin/perl stashenv: # stashenv: # Write shell script to reload environment. stashenv: # - Cameron Simpson, 15may1993 stashenv: # stashhotlist: #!/bin/sh stashhotlist: # stashhotlist: # Stash hotlists. stashhotlist: # - Cameron Simpson <cs@zip.com.au> 06sep95 stashhotlist: # stashweb: #!/usr/bin/perl -I/home/sid/cameron/etc/pl/cs stashweb: # stashweb: # Walk the WWW trees and make an archive to update the one on sureshot. stashweb: # - Cameron Simpson <cs@zip.com.au> 14jun96 stashweb: # stashxface: #!/usr/bin/perl stashxface: # stashxface: # Read fromaddrs and X-Face: data from stdin and save in face directory. stashxface: # - Cameron Simpson <cs@zip.com.au>, 14jul94 stashxface: # stat2html: #!/usr/bin/perl stat2html: # statpath: #!/usr/bin/perl statpath: # statpath: # Reduce a path to the extant components, tossing duplicates. statpath: # - Cameron Simpson <cs@zip.com.au> 19oct97 statpath: # std: #!/usr/bin/perl std: # std: # Seconds since epoch to human time. std: # - Cameron Simpson <cs@zip.com.au> std: # stdcc: #!/bin/sh stdcc: # stdcc: # Try really hard to run the most sane compiler we can with POSIX and XOPEN stdcc: # support. stdcc: # - Cameron Simpson stdcc: # stdenv: #!/bin/sh stdenv: # stdenv: # $# > 0 ==> run cmd with this type of stock path stdenv: # $# = 0 ==> run a shell stdenv: # # stic - convenient wrapper for the stic tools (Set of Tools for Image Collectors) strings: #!/usr/bin/perl strings: # strings: # Strings rewrite. - Cameron Simpson <cs@zip.com.au> strings: # strings: # Hook to mark start/end of block. strings: # Major recode. - cameron 18jun99 strings: # stripnuls: #!/usr/bin/perl stripnuls: # stripnuls: # Elide NULs and 255s from stdin, copying to stdout. stripnuls: # - Cameron Simpson <cs@zip.com.au>, 12aug94 stripnuls: # subfile: #!/bin/sh subn2n4: #!/usr/bin/perl subn2n4: # subn2n4: # Convert a subnet list of the form subn2n4: # nnnn/n subn2n4: # to the form subn2n4: # nnnn/nnnn subn2n4: # for squid acl lists. subn2n4: # - Cameron Simpson <cs@zip.com.au> 30apr2000 subn2n4: # suns: #!/bin/sh suns: # suns: # Emit machine list via netgroup. suns: # - Cameron Simpson <cs@zip.com.au> 24sep96 suns: # syncdns: #!/bin/sh syncdns: # syncdns: # Install new DNS stuff and reload. syncdns: # - Cameron Simpson <cs@zip.com.au> 04nov98 syncdns: # synceos: #!/bin/sh synceos: # synceos: # Make eos (our internal mail hub) match up. synceos: # - Cameron Simpson <cs@zip.com.au> 02nov99 synceos: # synchome: #!/bin/sh synchome: # synclinks: #!/bin/sh synclinks: # synclinks: # Rebuild my symlinks. synclinks: # - Cameron Simpson <cs@zip.com.au> 28feb99 synclinks: # syncnis: #!/bin/sh syncnis: # syncnis: # Install new NIS stuff and push. syncnis: # - Cameron Simpson <cs@zip.com.au> 04nov98 syncnis: # # syncopt - keep per-machine /opt in sync with shared one syncopt-bootstrap: #!/bin/sh syncoptall: #!/bin/sh syncoptall: # syncoptall: # Syncopt a bunch of machines. syncoptall: # - Cameron Simpson <cs@zip.com.au> 23jan2001 syncoptall: # syncoptall: # Switched to serialised (from bgssh) because our new RAID syncoptall: # croaks under the mount load. - cameron 29oct2001 syncoptall: # # syncstuff - synchronise files between the usual spots syncsysscripts: #!/bin/sh syncsysscripts: # syncsysscripts: # Sync everything to the master copies. syncsysscripts: # Run as root after running updsysscripts as me. syncsysscripts: # - Cameron Simpson <cs@zip.com.au> 16oct2001 syncsysscripts: # synczap: #!/bin/sh synczap: # synczap: # Propagate the adzap script and pattern file. synczap: # - Cameron Simpson <cs@zip.com.au> 21apr1999 synczap: # sysscripts: #!/bin/sh sysscripts: # sysscripts: # List those of my scripts to be installed for the system. sysscripts: # - Cameron Simpson <cs@zip.com.au> 09apr1997 sysscripts: # szcmp: #!/bin/sh szcmp: # t: #!/bin/sh t: # t: # TOC or extract various archive formats. t: # - Cameron Simpson <cs@zip.com.au> t: # t: # Iterative analysis of extensions; the combinations were getting too numerous. t: # - cameron 22jan1999 t: # t2: #!/bin/sh t2: # t2: # Run up X with settings suitable for Tribes2. t2: # - Cameron Simpson <cs@zip.com.au> 02feb2002 t2: # tag_fd: #!/bin/sh tag_fd: # tag_fd: # Tag a stream (or streams) with a prefix. tag_fd: # - Cameron Simpson <cs@zip.com.au> 18may99 tag_fd: # tailctl: #!/bin/sh tailctl: # tailf: #!/usr/bin/perl tailf: # tailf: # Multifile tail -f. - Cameron Simpson <cs@zip.com.au> tailf: # tailf: # Recode. - cameron 13feb2002 tailf: # tap: #!/bin/sh tap: # tap: # Run a logged script session attached to the specified serial port. tap: # - Cameron Simpson <cs@zip.com.au> 17may2002 tap: # taprd: #!/usr/bin/perl taprd: # tarpc: #!/bin/sh tarpc: # tarpc: # Collect a tarfile of an arbitrary directory from a PC via smbclient. tarpc: # Caveats: there must be a share name for an ancestor of the dir. tarpc: # - Cameron Simpson <cs@zip.com.au> from David White's example, 30jan97 tarpc: # tb: #!/bin/sh # tcpio - shell level TCP stream access tcplog: #!/bin/sh tcplog: # tcplog: # Fetch the last tcpdump log from del and graph usage. tcplog: # - Cameron Simpson <cs@zip.com.au> 07may99 tcplog: # tcplog2generic: #!/usr/bin/perl tcplog2generic: # tcplog2generic: # Parse tcpdump logs and emit data suitable for use by logtally. tcplog2generic: # - Cameron Simpson <cs@zip.com.au> 07may99 tcplog2generic: # teemail: #!/bin/sh teemail: # teemail: # Copy stdin to the named files and also append to $MAIL. teemail: # - Cameron Simpson, 06may94 teemail: # tellcisco: #!/bin/sh tellcisco: # tellcisco: # Dispatch commands to a cisco. tellcisco: # - Cameron Simpson <cs@zip.com.au> 19aug1999 tellcisco: # tellcisco: # Added -i 1 to work around CISCO tty driver bug. tellcisco: # - cameron 10sep1999 tellcisco: # tellcisco: # Use "secret" to retrieve password. - cameron, 05dec2001 tellcisco: # telnos: #!/bin/sh telnos: # telnos: # Append to a log. telnos: # - Cameron Simpson <cs@zip.com.au> telnos: # term: #!/bin/sh term: # term: # Generic open-a-window. term: # term: # Default location is tuned to my X11 setup (i.e. 103 pixels down from term: # the top of the screen). term: # The -big option is tuned to my X setup on a 1280x1024 screen. term: # - Cameron Simpson, December 1991 term: # termenv: #!/bin/sh termenv: # Use TERM to pass environment information to remote command. termenv: # termpager: #!/bin/sh termpager: # testpageurls: #!/bin/sh testpageurls: # testzap: #!/bin/sh text: #!/bin/sh tidy: #!/bin/sh tidy: # tidy: # Tidy up directories. tidy: # - Cameron Simpson <cs@zip.com.au> tidy: # tif2jpg: #!/bin/sh tif2jpg: # tif2jpg: # - Cameron Simpson <cs@zip.com.au> tif2jpg: # timeinseconds: #!/bin/sh timeinseconds: # timeinseconds: # Wrapper for time to print the user, system and real times in seconds timeinseconds: # to stderr (by default). - Cameron Simpson <cs@zip.com.au> 23apr99 timeinseconds: # timeout: #!/bin/sh timeout: # timeout: # Run a command with a real-time timeout. timeout: # - Cameron Simpson <cs@zip.com.au> timeout: # tk: #!/opt/bin/tkperl -w tk: # tk: # Dummy for learning Tkperl. tk: # - Cameron Simpson <cs@zip.com.au> 24mar97 tk: # tk: # total: #!/bin/sh total: # total: # Add a total of an arbitrary column to a report. total: # - Cameron Simpson <cs@zip.com.au> 14apr98 total: # tplt: #!/bin/sh tplt: # tplt: # Emit a template for the named file on stdout. tplt: # - Cameron Simpson <cs@zip.com.au> 08apr1997 tplt: # tracemac: #!/bin/sh tracemac: # tracemac: # Locate a host from its MAC. tracemac: # - Cameron Simpson <cs@zip.com.au> 19aug99 tracemac: # trimlog: #!/bin/sh trimout: #!/usr/bin/perl trn-mailposter: #!/bin/sh trn-newsposter: #!/bin/sh trusslog: #!/bin/sh trusslog: # trusslog: # Run a truss of a process keeping the last set of output lines in a rolling logfile. trusslog: # - Cameron Simpson <cs@zip.com.au> 03jan2002 trusslog: # ttyexec: #!/bin/sh ttyexec: # ttyexec: # Set up the terminal then run a command. ttyexec: # - Cameron Simpson <cs@zip.com.au> 03jan97 ttyexec: # ttylabel: #!/bin/sh ttylabel: # ttylabel: # Set terminal's title and icon strings. ttylabel: # - Cameron Simpson <cs@zip.com.au> ttylabel: # ttylogtag: #!/bin/sh ttylogtag: # ttylogtag: # A tag based on the tty for use in a filename such as a log. ttylogtag: # - Cameron Simpson <cs@zip.com.au> 05sep2000 ttylogtag: # ttysane: #!/bin/sh ttysane: # - Cameron Simpson <cs@zip.com.au> ttysize: #!/bin/sh ttysize: # ttysize: # Emit the terminal size in columns and rows. ttysize: # - Cameron Simpson <cs@zip.com.au> 15oct2000 ttysize: # tws: #!/bin/sh tws: # tws: # Trim whitespace. tws: # Strip leading and trailing whitespace and turn [ \t]+ into tws: # a single space. tws: # - Cameron Simpson <cs@zip.com.au> 23jul2000 tws: # txturls: #!/bin/sed -nf txturls: # txturls: # Extract http: URLs from plain text. txturls: # - Cameron Simpson <cs@zip.com.au> 24may2000 txturls: # udb2ldif: #!/usr/bin/perl udb2ldif: # udb2ldif: # Emit a dump of the user db in LDIF. udb2ldif: # - Cameron Simpson <cs@zip.com.au> 21nov97 udb2ldif: # ufcchk: #!/usr/bin/perl ufcchk: # ufcchk: # Parse output from ufc and check against encryptions. ufcchk: # ulinks: #!/bin/sh ulinks: # ulinks: # Generate the symlinks which should be in /u. ulinks: # - Cameron Simpson <cs@zip.com.au> 07jun2001 ulinks: # um: #!/bin/sh um: # Background url mind. - Cameron Simpson <cs@zip.com.au> umcite2url: #!/bin/sh umcite2url: # umcite2url: # Take a URL-Minder citation and return the relevant page. umcite2url: # - Cameron Simpson <cs@zip.com.au> 10feb99 umcite2url: # uml1: #!/bin/sh unacs: #!/usr/bin/perl unb64: #!/usr/bin/perl unb64: # unb64: # Decode Base64 stuff and emit. unb64: # - Cameron Simpson <cs@zip.com.au> 21may1998 unb64: # unbg: #!/bin/sh unbg: # unbg: # Add the current background to the list of backgrounds to suppress unbg: # and load a new one. unbg: # - Cameron Simpson <cs@zip.com.au> 06oct2000 unbg: # unbs: #!/bin/sh unbs: # unbs: # Remove nroff-style underlining and overstriking. unbs: # Works for other stuff, too. unbs: # - Cameron Simpson <cs@zip.com.au> unbs: # uncpp: #!/usr/bin/perl uncpp: # unctrl: #!/usr/bin/perl unctrl: # unctrl: # Replace control characters with printable forms. unctrl: # uncurly: #!/bin/sh uncurly: # uncurly: # Replace {foo} with $foo in the specified file, for a specified uncurly: # list of "foo". uncurly: # - Cameron Simpson <cs@zip.com.au> 27may2001 uncurly: # uncvs: #!/bin/sh uncvs: # uncvs: # Remove a file from CVS control. uncvs: # - Cameron Simpson <cs@zip.com.au> 09apr97 uncvs: # undblspc: #!/usr/bin/perl undblspc: # undblspc: # Strip double spacing from text. undblspc: # Try to cope with mixtures and nondoublespaced text. undblspc: # - Cameron Simpson <cs@zip.com.au> 26mar2000 undblspc: # undupmail: #!/usr/bin/perl undupmail: # undupmail: # Strip duplicates from a UNIX-format mail file. undupmail: # If items have a message-id, fine. undupmail: # Items without message-ids we work on the References: line, so you undupmail: # only get to keep one reply. undupmail: # Items with neither do an MD5 checksum of the body. undupmail: # - Cameron Simpson <cs@zip.com.au> 14jul99 undupmail: # unfontise: #!/usr/bin/perl unfontise: # unfontise: # Take a fontised string as appears in Subject: lines and attachment descriptions unfontise: # and convert it to raw form. See RFC2047. unfontise: # - Cameron Simpson <cs@zip.com.au> 01feb2002 unfontise: # # unhashpod - extract the pod content from a script unhdr: #!/bin/sed -f unhdr: # unhdr: # Strip RFC822 headers from input. unhdr: # - Cameron Simpson 17feb95 unhdr: # unhexify: #!/usr/bin/perl -p unhtml: #!/bin/sh unhtml: # unhtml: # Mangled HTML to put URLs inline with the links for easy grabbing. unhtml: # - Cameron Simpson <cs@zip.com.au> 17may2002 unhtml: # unixtime: #!/bin/sh unixtime: # unixtime: # Code by John Rosauer <jar@rmb.com.au> unixtime: # Widget to monitor UNIX time as Sun Sep 09 11:46:40 EST 2001 unixtime: # approaches (1000000000 epoch seconds). unixtime: # - Cameron Simpson <cs@zip.com.au> unixtime: # unixtime: # \ unlink: #!/usr/bin/perl unlink: # unlink: # Usage: unlink [-v] [files...] unlink: # unlock: #!/bin/sh unlock: # unlock: # Kill the process holding a lock. unlock: # - Cameron Simpson <cs@zip.com.au> 13jul2000 unlock: # -f: remove the lock anyway. unlock: # unlsdbm: #!/usr/bin/perl unlsdbm: # unpath: #!/usr/bin/perl unpath: # unpath: # Break up a colon separated path. unpath: # - Cameron Simpson <cs@zip.com.au> unpath: # unpdf: #!/bin/sh unpdf: # unpdf: # Wrapper for pdftohtml which makes a coarse attempt at paragraphing. unpdf: # - Cameron Simpson <cs@zip.com.au> 01jun2002 unpdf: # unportfwd: #!/bin/sh unportfwd: # unportfwd: # Turn off the portfwd sshs. unportfwd: # - Cameron Simpson <cs@zip.com.au> 06nov99 unportfwd: # unprog: #!/usr/bin/perl unprog: # unprog: # Massage archie responses into a more useful form. unprog: # - Cameron Simpson, 19oct92 unprog: # unps: #!/bin/sh unps: # unps: # Like strings(1) for PostScript. unps: # - Cameron Simpson, 21nov92 unps: # unqp: #!/usr/bin/perl unqp: # unqp: # Decode Quoted-Printable stuff and emit. unqp: # - Cameron Simpson <cs@zip.com.au> 21may98 unqp: # unshar: #!/bin/sh unshar: # unsnap: #!/bin/sh unsnap: # untar: #!/usr/bin/perl untar: # untar: # Run tar extract with tidier verbose mode. untar: # - Cameron Simpson <cs@zip.com.au> untar: # untilde: #!/usr/bin/perl untilde: # untilde: # Replace ~ or ~user with a pathname. untilde: # - Cameron Simpson <cs@zip.com.au> 21nov2001 untilde: # untulp: #!/bin/sh untulp: # untulp: # Copy TULP list info into majordomo files. untulp: # - Cameron Simpson <cs@zip.com.au> 24jun96 untulp: # unum: #!/bin/sh unum: # unum: # Take a URL-Minder Cancel URL and use it. unum: # - Cameron Simpson <cs@zip.com.au> 28jan99 unum: # unuumesg: #!/usr/bin/perl unuumesg: # unuumesg: # Read a nonMIME message and unpack the uuencoded portions into files, unuumesg: # passing the remaining content through to stdout. This is intended as unuumesg: # an adjunct to enmime, which does this in a subdirectory and then unuumesg: # emits a MIME message is any uuencoded parts were found. unuumesg: # - Cameron Simpson <cs@zip.com.au> 12jun2002 unuumesg: # unz: #!/bin/sh unz: # unz: # Uncompress a file. I'm so lazy. unz: # - Cameron Simpson <cs@zip.com.au> 10apr99 unz: # up: #!/bin/sh upd822ndx: #!/bin/sh upd822ndx: # upd822ndx: # Update the 822ndx in a given directory. upd822ndx: # updaliases: #!/usr/bin/perl updaliases: # updaliases: # Generate the entire aliases file from the CISRA DB. updaliases: # - Cameron Simpson <cs@zip.com.au> 21may1997 updaliases: # updaliases: # Generate descriptions. updaliases: # - cameron, 11feb1999 updaliases: # updaliases: # Get user and group data from the mysql database now. updaliases: # update: #!/bin/sh update: # update: # Update changes to current dir only. update: # - Cameron Simpson <cs@zip.com.au> 21may1997 update: # updcal: #!/bin/sh updcal: # updcal: # Feed chkcal into ldapmodify to apply the changes. updcal: # - Cameron Simpson <cs@zip.com.au> 11jan99 updcal: # updciscocfg: #!/bin/sh updciscocfg: # updciscocfg: # Rewrite the automatic portion of the CISCO switch config file. updciscocfg: # - Cameron Simpson <cs@zip.com.au> 10jul98 updciscocfg: # updciscos: #!/bin/sh updciscos: # updciscos: # Rewrite the bits of the CISCO config we're happy with. updciscos: # - Cameron Simpson <cs@zip.com.au> 10sep99 updciscos: # updethersfromarp: #!/bin/sh updethersfromarp: # updethersfromarp: # Update the /etc/ethers file from current arp -a listing. updethersfromarp: # - Cameron Simpson <cs@zip.com.au> 01sep95 updethersfromarp: # updethersfromarp: # Update for Solaris, fix sorting bug. - cameron 25mar97 updethersfromarp: # updethersfromhdb: #!/usr/bin/perl updethersfromhdb: # updethersfromhdb: # Update the ethers file from the db. updethersfromhdb: # - Cameron Simpson <cs@zip.com.au> 08jul98 updethersfromhdb: # updexttbl: #!/bin/sh updfiles: #!/bin/sh updfiles: # updfiles: # Accept chkfiles output on stdin, comm against snapshot and updfiles: # write cpio archive of changed files. updfiles: # - Cameron Simpson <cs@zip.com.au> 17sep96 updfiles: # updfloorplan: #!/usr/bin/perl updfloorplan: # updfloorplan: # Construct the desk->info mapping in auto/floorplan. updfloorplan: # - Cameron Simpson <cs@zip.com.au> 08sep99 updfloorplan: # updgrep: #!/usr/bin/perl updgrep: # updgrep: # Grep with cs::Upd display. updgrep: # - Cameron Simpson <cs@zip.com.au> 1nov2000 updgrep: # updgroup: #!/usr/bin/perl -w updgroup: # updgroup: # Recompute the UNIX group file. updgroup: # - Cameron Simpson <cs@zip.com.au> 17apr2001 updgroup: # updhdb: #!/usr/bin/perl -w updhdb: # updhdb: # Take the user database, trace their phone wiring, match against host updhdb: # wiring, set USER field of HOST thusly. updhdb: # - Cameron Simpson <cs@zip.com.au> 23aug2000 updhdb: # updimdb: #!/usr/bin/perl updimdb: # updimdb: # Update an image db. updimdb: # - Cameron Simpson <cs@zip.com.au> 13apr99 updimdb: # updldap: #!/usr/bin/perl updldap: # updldap: # Emit shell commands to update the directory server with current updldap: # users and group memberships. updldap: # - Cameron Simpson <cs@zip.com.au> 07jan98 updldap: # updlinkforest: #!/usr/bin/perl updlinkforest: # updlinkforest: # Update a directory of symlinks. updlinkforest: # - Cameron Simpson <cs@zip.com.au> 10apr2001 updlinkforest: # updlinklist: #!/usr/bin/perl updlinklist: # updlinklist: # Read URLs and titles from stdin and update a state file. updlinklist: # Emit new URLs and titles on stdout. updlinklist: # - Cameron Simpson <cs@zip.com.au> 25sep2000 updlinklist: # updlinklist: # Recode to use MUCH less memory and a temporary file updlinklist: # (on the premise that the input is much smaller than the state). updlinklist: # Probably cheaper CPUwise, too. updlinklist: # - Cameron Simpson <cs@zip.com.au> 06nov2000 updlinklist: # updlistpost: #!/bin/sh updlistpost: # updlistpost: # Stand on news server machine. updlistpost: # Run output through sh to create missing groups. updlistpost: # - Cameron Simpson <cs@zip.com.au> 17dec97 updlistpost: # updlistsave: #!/bin/sh updlistsave: # updlistsave: # Stand in ~listsave. updlistsave: # Run output through sh to update files. updlistsave: # - Cameron Simpson <cs@zip.com.au> 17dec97 updlistsave: # updmd5index: #!/bin/sh updmd5index: # updmd5index: # Update the .md5index file with newer files. updmd5index: # - Cameron Simpson <cs@zip.com.au> 04dec98 updmd5index: # updnetgroup: #!/bin/sh updnetgroup: # updnetgroup: # Rewrite that portion of the netgroup file which derives directly updnetgroup: # from the hosts table. updnetgroup: # - Cameron Simpson <cs@zip.com.au> 10oct2001 updnetgroup: # updnis: #!/bin/sh updnis: # updnis: # Update the NIS checkout for a recent change. updnis: # - Cameron Simpson <cs@zip.com.au> 17aug98 updnis: # updopt: #!/bin/sh updopt: # updopt: # Update my snapshots of CISRA's /usr/local/opt*. updopt: # - Cameron Simpson <cs@zip.com.au> 11feb2002 updopt: # updpasswd: #!/usr/bin/perl -w updpasswd: # updpasswd: # Patch passwd file to match user db. updpasswd: # - Cameron Simpson <cs@zip.com.au> 20nov1997 updpasswd: # updrawmailrc: #!/opt/bin/perl updrawmailrc: # updrawmailrc: # Update mailrc.rawdb. updrawmailrc: # - Cameron Simpson <cs@zip.com.au> 22may98 updrawmailrc: # updsysscripts: #!/bin/sh updsysscripts: # updsysscripts: # Install my scripts in the system directory. updsysscripts: # - Cameron Simpson <cs@zip.com.au> 09apr1997 updsysscripts: # updudb: #!/usr/bin/perl updudb: # updudb: # Take the user database, trace their phone wiring and overwrite their DESK updudb: # value according to the phone setting. updudb: # - Cameron Simpson <cs@zip.com.au> 18oct2000 updudb: # updunison: #!/usr/bin/perl updunison: # updvmindex: #!/usr/bin/perl updvmindex: # updvmindex: # Update index file for a folder. updvmindex: # - Cameron Simpson <cs@zip.com.au> updvmindex: # updzip: #!/bin/sh updzip: # updzip: # Update my web pages. updzip: # - Cameron Simpson <cs@zip.com.au> 11nov97 updzip: # uring: #!/bin/sh uring: # uring: # Ring my URL bookmarks. uring: # - Cameron Simpson <cs@zip.com.au> 26jun98 uring: # urlmap2js: #!/usr/bin/perl urlmap2js: # urlmap2js: # Read a db holding the remapping shExprs and emit equivalent JavaScript. urlmap2js: # - Cameron Simpson <cs@zip.com.au> 07aug98 urlmap2js: # urlmind: #!/bin/sh urlmind: # urlmind: # Register a page with the URL Minder urlmind: # <http://www.netmind.com/URL-minder/URL-minder.html>. urlmind: # urlmind: # - Cameron Simpson <cs@zip.com.au> 12sep95 urlmind: # urls: #!/usr/bin/perl urls: # urls: # Extract URLs from HTML on stdin. urls: # - Cameron Simpson <cs@zip.com.au> 24aug2000 urls: # urlshow: #!/bin/sh urlshow: # urlshow: # Display URLs with a browser. urlshow: # - Cameron Simpson <cs@zip.com.au> urlshow: # urlshow: # Added netscape -remote support. cameron, 05may1995 urlshow: # Removed mosaic support. cameron, 10nov1997 urlshow: # Netscape takes multiple -remote()s! cameron, 10nov1997 urlshow: # Jamie Zawinski's <jwz@netscape.com> netscape-remote.c used instead. - cameron, 16mar1999 urlshow: # support some meta prefixes. cameron 28mar2000 urlshow: # us: #!/bin/sh us: # us: # Autostart browser and show URLs. Backgrounds so the user can get on us: # with things. us: # - Cameron Simpson <cs@zip.com.au> us: # us: # Catch "us -" and squirrel away stdin. - cameron 25jun2001 us: # usc: #!/bin/sh usc: # "Clean" URLshow. - Cameron Simpson <cs@zip.com.au> 07may2001 useraliases: #!/bin/sh userinfo2sh: #!/usr/bin/perl userinfo2sh: # userinfo2sh: # Emit user information as shell assignments. userinfo2sh: # - Cameron Simpson <cs@zip.com.au> 19oct2000 userinfo2sh: # uud: #!/bin/sh uudecode: #!/usr/bin/perl uudecode: # uudecode: # uumerge - merge multiple uuencoded split files uudecode: # uue: #!/bin/sh uuencode: #!/usr/bin/perl vcard2txt: #!/bin/sh vcard2txt: # vcard2txt: # Read a vcard from stdin, write it out prettily. vcard2txt: # - Cameron Simpson <cs@zip.com.au> 14apr2001 vcard2txt: # vdoc: #!/bin/sh vdoc: # vdoc: # View an M$ Word document. No idea why people imagine this is a useful vdoc: # format to send text around in, but there you go. vdoc: # - Cameron Simpson <cs@zip.com.au> 26mar2000 vdoc: # vgrep: #!/usr/bin/perl vgrep: # vgrep: # Visual grep. vgrep: # vm: #!/bin/sh vm: # vm: # Enter my mail folder and run vi as a user agent. vm: # - Cameron Simpson <cs@zip.com.au> vm: # vma: #!/bin/sh vma: # vma: # "vm all" - shortcut to my mixed inbox. vma: # - Cameron Simpson <cs@zip.com.au> 19jan99 vma: # vmfind: #!/usr/bin/perl vmfind: # vmfind: # Locate the references patterns and make a folder for vm. vmfind: # Blow away the folder afterwards. vmfind: # - Cameron Simpson, 20nov93 vmfind: # vmfw: #!/bin/sh vmfw: # vmfw: # Expects to be called from inside vm with input of the form vmfw: # itemnum author topic vmfw: # - Cameron Simpson <cs@zip.com.au> vmfw: # vmin: #!/bin/sh vmin: # vmin: # Expects to be called from inside vm with input of the form vmin: # itemnum author topic vmin: # - Cameron Simpson <cs@zip.com.au> vmin: # vmsq: #!/bin/sh vmsquash: #!/usr/bin/perl vmsquash: # vmsquash: # Renumber items in mail directory to be consecutive from 1. vmsquash: # - Cameron Simpson, 17feb94 vmsquash: # vmsquash: # -t Order by Date: (or mtime failing that) and drop duplicate msgids. vmsquash: # - Cameron Simpson <cs@zip.com.au> 18oct94 vmsquash: # vmt: #!/bin/sh vmt: # vmt: # Shortcut to threaded mailbox. vmt: # - Cameron Simpson <cs@zip.com.au> 20jan99 vmt: # vmt: #exec term -n "mutt +attn" -e mutt -f "$MAILDIR/attn" vnc: #!/bin/sh vnc: # vnc: # Wrapper for the vnc programs. vnc: # - Cameron Simpson <cs@zip.com.au> 26jul1999 vnc: # vpc: #!/bin/sh vpc: # vpc: # View a PC desktop with VNC. vpc: # - Cameron Simpson <cs@zip.com.au> 04dec2000 vpc: # vpic: #!/bin/sh vpn@home: #!/bin/sh vpn@home: # vpn@home: # Rig VPN-via-ssh for dialin from home. vpn@home: # - Cameron Simpson <cs@zip.com.au> 23oct99 vpn@home: # vpnendpoint: #!/bin/sh vpnendpoint: # vpnendpoint: # Dummy script to run at remote end of ssh used for port forwarding. vpnendpoint: # Tails my console file (which is handy for watching the remote host) vpnendpoint: # and copy input to the log (keeps link alive, detects link down). vpnendpoint: # See the portfwd script for use. vpnendpoint: # - Cameron Simpson <cs@zip.com.au> 07oct1999 vpnendpoint: # vpnendpoint: # one day I'll make these tunable vpnssh: #!/bin/sh vpnssh: # vpnssh: # Run a plain port forwarding ssh with steady input, vpnssh: # to a remote ssh server. vpnssh: # - Cameron Simpson <cs@zip.com.au> 29jan2000 vpnssh: # vptx: #!/usr/bin/perl vptx: # vptx: # Read text files and emit index information of the form vptx: # fname word lineno offset vptx: # vq: #!/bin/sh vtroff: #!/bin/sh vvnc: #!/bin/sh vvnc: # vvnc: # Run a VNC showing another VNC. vvnc: # Basicly a hack to do backing store. vvnc: # - Cameron Simpson <cs@zip.com.au> 05dec2001 vvnc: # w3: #!/bin/sh w3history2html: #!/usr/bin/perl w3history2html: # w3history2html: # Read global history file from stdin and emit HTML equivalent. w3history2html: # - Cameron Simpson, cs@zip.com.au, 10jun94 w3history2html: # wait4stdin: #!/bin/sh wait4stdin: # wait4stdin: # Gather up all of stdin and then run command. wait4stdin: # Useful for delaying the commencement of an especially expensive wait4stdin: # command (eg resource hungry or holds a lock for an excessive time) wait4stdin: # until its input is ready. (In fact, that's the only use I can think wait4stdin: # of for this script, but then that was what I needed.) wait4stdin: # - Cameron Simpson <cs@zip.com.au> 25sep2000 wait4stdin: # waitpid: #!/bin/sh waitpid: # waitpid: # Wait for a set of process ids to die. waitpid: # Needs kill priviledge on the processes. waitpid: # - Cameron Simpson <cs@zip.com.au> 26sep2000 waitpid: # wantrxvtbg: #!/bin/sh wantrxvtbg: # wantrxvtbg: # Do we want tty backdrops? - Cameron Simpson <cs@zip.com.au> 24oct2000 wantrxvtbg: # wantrxvtbg: # Skip some underpowered or otherwise to-be-left-alone hosts. - cameron 03jan2001 wantrxvtbg: # watchcmd: #!/bin/sh watchcmd: # watchcmd: # Repeatedly run a command and pipe through vdis. watchcmd: # - Cameron Simpson <cs@zip.com.au> 15aug2000 watchcmd: # watchlinkpages: #!/bin/sh watchlinkpages: # watchlinkpages: # Watch a set of link post pages (eg freshmeat) and report new links. watchlinkpages: # - Cameron Simpson <cs@zip.com.au> 29jul2000 watchlinkpages: # watchnetstat: #!/usr/bin/perl watchnetstat: # watchnetstat: # Monitor netstat for ESTABLISHED connections and sort on oldest. watchnetstat: # - Cameron Simpson <cs@zip.com.au> 30aug99 watchnetstat: # watchweblogs: #!/bin/sh watchweblogs: # watchweblogs: # Watch a set of weblogs and report new links. watchweblogs: # - Cameron Simpson <cs@zip.com.au> 29jul2000 watchweblogs: # watchweblogsets: #!/bin/sh watchweblogsets: # watchweblogsets: # Monitor web logs as specified in the dirs on the input. watchweblogsets: # - Cameron Simpson <cs@zip.com.au> 31jul2000 watchweblogsets: # wcat: #!/bin/sh web822: #!/usr/bin/perl web822: # web822: # Read RFC822 message from stdin and emit it in HTML form. web822: # - Cameron Simpson <cs@zip.com.au> web822: # webfixperms: #!/bin/sh webfixperms: # webfixperms: # Walk the proxy tree making directories group orject accessable. webfixperms: # It should be run _on_ the proxy host, not across NFS! webfixperms: # - Cameron Simpson <cs@zip.com.au> 31jul96 webfixperms: # webnews: #!/usr/bin/perl webnews: # webster: #!/usr/bin/perl webster: # webster: # Access a webster server. - Cameron Simpson, cs@zip.com.au webster: # webuncache: #!/usr/bin/perl webuncache: # webuncache: # Remove a bogus (or simply out-of-date) entry from the cache. webuncache: # - Cameron Simpson <cs@zip.com.au> 26jul96 webuncache: # whereis: #!/bin/sh which: #!/usr/bin/perl which: # which: # Locate a command. - Cameron Simpson <cs@zip.com.au> which: # winclause: #!/bin/sh winclause: # winclause: # Grab a clause from a Windows-style .ini file. winclause: # - Cameron Simpson <cs@zip.com.au> 14jul2001 winclause: # winsnap: #!/bin/sh winsnap: # winsnap: # Grab a window and put it as a gif on my web site, return the URL. winsnap: # Stripped out of bgfg. winsnap: # - Cameron Simpson <cs@zip.com.au> winsnap: # winsnap: # Grab a PNG. - Cameron Simpson <cs@zip.com.au> 25may2000 winsnap: # wire: #!/usr/bin/perl wire: # wire: # Modify the wiring database. wire: # - Cameron Simpson <cs@zip.com.au> 17jul98 wire: # wired: #!/usr/bin/perl wired: # wired: # Select only wired hosts from the names supplied. wired: # - Cameron Simpson <cs@zip.com.au> 01aug2001 wired: # wiring: #!/bin/sh wiring: # wiring: # Run ring on the wiring data. wiring: # - Cameron Simpson <cs@zip.com.au> 14jul98 wiring: # withSOURCE_DISPLAY: #!/bin/sh withSOURCE_DISPLAY: # - Cameron Simpson <cs@zip.com.au> 22mar2001 withpgppass: #!/bin/sh withpgppass: # withpgppass: # Run a command with $PGPPASS set (typically "ring -p" which does multiple pgp invocations). withpgppass: # - Cameron Simpson <cs@zip.com.au> 03may2002 withpgppass: # wm: #!/bin/sh wm: # wm: # Invoke our window manager of choice. wm: # wman: #!/bin/sh wman: # wman: # Use Mosaic to bring up a manual page. wman: # - Cameron Simpson, cs@zip.com.au, 22jun94 wman: # wmap: #!/bin/sh wmap: # wmap: # Fetch and optionally display a weather map. wmap: # wordindex: #!/usr/bin/perl -w wordindex: # wordindex: # Manipulate a keyword index of a bunch of text files. wordindex: # - Cameron Simpson <cs@zip.com.au> 22apr2002 wordindex: # wu: #!/bin/sh xauth_key: #!/usr/bin/perl xc: #!/bin/sh xh: #!/bin/sh xinfo: #!/usr/bin/perl xinfo: # xinfo: # Emit xdpyinfo output in handy shell sourceable form. xinfo: # - Cameron Simpson <cs@zip.com.au> xinfo: # xl: #!/usr/bin/perl xl: # xl: # Wrapper for xload. xl: # xlo: #!/bin/sh xlo: # xlo: # Run a very nice xlock and log reason if given. xlo: # - Cameron Simpson <cs@zip.com.au> xlo: # xlocal: #!/bin/sh xlocal: # xlocal: # Strip local versions of $DISPLAY down to :n. xlocal: # - Cameron Simpson <cs@zip.com.au> xlocal: # xls: #!/bin/sh xls: # xls: # List windows with names. xls: # - Cameron Simpson <cs@zip.com.au> xls: # xm: #!/bin/sh xm: # xmr: #!/bin/sh xpm2rxvt: #!/bin/sh xpm2rxvt: # xpm2rxvt: # Set the background of an rxvt from an XXPM file. xpm2rxvt: # - Cameron Simpson <cs@zip.com.au> 20nov2000 xpm2rxvt: # xptr123: #!/bin/sh xptr132: #!/bin/sh xq: #!/bin/sh xq: # xq: # Query or hack the live X resource db. xq: # - Cameron Simpson <cs@zip.com.au> xq: # xrdb_load: #!/bin/sh xrefmailitem: #!/bin/sh xrefmailitem: # xrefmailitem: # Crossfile mail item based on addresses. xrefmailitem: # - Cameron Simpson <cs@zip.com.au> 24may2002 xrefmailitem: # xrefmhdir: #!/bin/sh xresmatch: #!/usr/bin/perl xresmatch: # xt: #!/bin/sh xt24: #!/bin/sh xtc: #!/bin/sh xtdemo: #!/bin/sh xterm_console: #!/bin/sh xterm_console: # xterm_console: # Console window. xterm_console: # - Cameron Simpson <cs@zip.com.au> xterm_console: # xterm_sync: #!/bin/sh xterm_sync: # xterm_sync: # Do NOT use -e in xterm-args! xterm_sync: # xth: #!/bin/sh xtn: #!/bin/sh xtn24: #!/bin/sh xunclip: #!/bin/sh xunclip: # xunclip: # "xclip -o with guarrenteed trailing newline, because bash's backticks are buggy. xunclip: # - Cameron Simpson <cs@zip.com.au> 31may2002 xunclip: # xv24: #!/bin/sh xvbw: #!/bin/sh xvbw: # xvbw: # xv for black and white displays xvbw: # xvcol: #!/bin/sh xvcol: # xvcol: # xv for colour displays xvcol: # xvmax: #!/bin/sh xvshow: #!/bin/sh xvshow: # xvslide: #!/bin/sh xvurl: #!/bin/sh xvurl: # xvurl: # View a URL. Fetch and hand to something other than my web browser. xvurl: # Spurred into implementation by the Liberty Meadows comics strip, xvurl: # which is funny but too small, so XV to the rescue! xvurl: # - Cameron Simpson <cs@zip.com.au> 12jun2001 xvurl: # xwdtops: #!/bin/sh xwdtops: # xwdtops: # X window -> PostScript. xwdtops: # xxargs: #!/usr/bin/perl xxargs: # xxargs: # Having pretty much had it with xargs, which is a busted piece of crap due xxargs: # to its quoting/whitepsace problems, here is a less featured but more robust one. xxargs: # - Cameron Simpson <cs@zip.com.au> 20dec2001 xxargs: # ypm: #!/bin/sh ytr: #!/bin/sh z: #!/bin/sh z: # z: # Partner for t, v and x. z: # - Cameron Simpson <cs@zip.com.au> 11mar1999 z: # z: # Handle directories. - cameron 27jun2000 z: # Gzip by default because bzip2 uses much CPU. - cameron 03jul2000 z: # zipfs: #!/bin/sh zipfs: # zipfs: # Set up a SCSI Zip medium in a Solaris box. zipfs: # - Cameron Simpson <cs@zip.com.au> 22oct96 zipfs: # zippop: #!/bin/sh zippop-big: #!/bin/sh zp: #!/bin/sh zp: # zp: # zp: # aps='aps -T "$arg"' ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������