#!/usr/local/bin/rxx

/*
   (c) copyright 1995, Paul Zarnowski and Cornell University
       (see "Legal Information", below)

   daily.backup

   For each registered client node, if:
   1)  A successful backup has not occurred within the last N days, and
   2)  The node-admin wants to be notified, then
       send a mailfile to the node-admin indicating:
       1)  Their node has not been backed up within the last N days, and
       2)  Which filespaces, and
       3)  The last successful incremental backup of their node occured on X.
   If the "notification value" is negative, then we always notify the
   node-admin whether there is a recent backup or not.  However, the content
   and subject of the E-mail will be different, depending on whether a
   recent backup has occured or not.  The absolute value of the "notification
   value" is used to determine whether the last backup is "recent" or not.

   The "notification value" is stored as part of the "CONTACT" field for
   the ADSM node.  The CONTACT field is parsed by the ParseContact function.

   Input:
     - qidfile:         contains id & password of ADSM query administrator
     - QUERY NODE:      nodename, owner, N, notify-flag, platform
     - QUERY FILESPACE: days-since-last-backup (by filespace)
     - QUERY EVENT: status

   Output:
     - Appends to history file
     - Summary email report to "mailto" address
     - Notification emails to node-owners (one per node-owner)

   Pre-req's:
     edate        - external rexx function
     Make sure you set the parameters, below.

   Author Information:
     Paul Zarnowski
     Cornell Information Technologies
     Ithaca, NY  14853-2601
     psz1@cornell.edu

   Update History:
     1-Jul-94 psz1:  Initial version
     3-Apr-95 psz1:  Added "notify always" option ($NOTIFY = -1) 
    19-Apr-95 psz1:  Modified "notify always" option ($NOTIFY < 0)
     8-Jun-95 psz1:  Added special case for no backups (treat as failure)
*/

/* Parameters */
  G.=""
  topdir="/u/adsm-mon"
  qidfile = topdir"/adm/qidfile"  /* ADSM Query Administrator ID & PASSWORD */
  FILENAME=edate(S,,-1,L)
  G.$MAILTO="adsm-maint"                        /* Send Summary Report to */
  G.$MAILADMIN="adsm-maint@nodename1.cornell.edu" /* mail questions here  */
  G.$SUMMARY=topdir"/log/backlog/"FILENAME      /* File for Summaries     */
  G.$MAILDIR="/tmp/adsm.daily.nodemail"         /* Temp dir for E-mail    */
  G.$HISTORY=topdir"/log/adsm.backup.history"   /* History file           */
  G.$HISTNB=topdir"/log/adsm.notbacked.history" /* Nobackup history file  */
  G.$WIDTH=79
  G.$SEPARATOR1=copies("= ",G.$WIDTH % 2)"="
  G.$SEPARATOR2=copies("- ",G.$WIDTH % 2)"-"

  G.$NOW = edate(U,,,L) time()               /* Get current date & time */
  G.$DEBUG = 0

/* Initialize statistics */
  G.$NOCONTACT = ""       /* list of nodes which never contacted server */
  G.$LOCKED    = ""       /* list of locked nodes */
  G.$IGNORED   = ""       /* list of nodes who don't want notification */
  G.$NOTBACKED = ""       /* list of nodes not backed up recently */
  G.$EMAIL.0   = 0        /* Array of E-mail recipients */
  EMAIL.       = 0        /* = 1, if we have encountered this E-mail */
  NL0.         = ""       /* NL0.email = list of ignored nodes for E-mail */
  NL1.         = ""       /* NL1.email = list of neg notify, recent backup */
  NL2.         = ""       /* NL2.email = list of pos notify, recent backup */
  NL3.         = ""       /* NL3.email = list of nodes to be notified */
  SUBJECT.     = ""       /* SUBJECT.email = subject for E-mail */

/* Parse qidfile */
  /* The qidfile contains 1 line containing an ADSM admin-id & passwd */
  rc = popen('/bin/head -1' qidfile)
  if (rc <> 0) then exit 12
  parse pull id pswd .
  if (pswd = "") then do
    call log "Invalid ID file."
    exit 12
    end

  G.$ADSMQID   = id       /* for use by osd_ADSMQstack */
  G.$ADSMQPASS = pswd

/* Remove temp files if they exist. */
  "/bin/test -f" G.$SUMMARY
  if (rc=0) then "/bin/rm -f --" G.$SUMMARY
  call CleanTempFiles
  "/bin/mkdir" G.$MAILDIR
  if (rc <> 0) then do
    say "Unexpected RC" rc "from mkdir" G.$MAILDIR
    call finish
    end

  nodelist=GetNodeInfo()  /* Get info from ADSM Q NODES FORMAT=DETAILED  */

/* Get FileSpace info from ADSM Q FILESPACE. */
  call GetFilespaceInfo() 

/* Get Event info from ADSM Q EVENTS. */
  call GetEventInfo()

/* Check each node to see if hasn't been backed up recently. */
  nn = nodelist
  do while (nn <> "")
    parse value nn with node nn
    email = NC.node.$ADMINEMAIL
    if (email="") then email = NC.node.$OWNEREMAIL
    b = CheckBackup(node)
    if (G.$DEBUG) then say "CheckBackup("node") =" b
    if (^EMAIL.email) then do
      i = G.$EMAIL.0
      i = i + 1
      G.$EMAIL.i = email
      G.$EMAIL.0 = i
      EMAIL.email = 1
      end
    select
      when (b=0) then NL0.email = NL0.email node
      when (b=1) then NL1.email = NL1.email node
      when (b=2) then NL2.email = NL2.email node
      when (b=3) then NL3.email = NL3.email node
      otherwise say "Invalid value returned from CheckBackup("node") -" b
      end
    end

/* Prepare Summary Report */
  if (G.$DEBUG) then say "Calling PrepSummary"
  call PrepSummary 

/* Prepare mailfile for each E-mail recipient */
  n = G.$EMAIL.0
  do i = 1 to n
    email = G.$EMAIL.i
    if (G.$DEBUG) then say "Calling PrepEmail("email")"
    if (PrepEmail(email) <> 0) then G.$EMAIL.i = ""
    end

/* Append statistics to history log */
  call UpdateHistory(G.$HISTORY)
  call UpdateNOBHistory(G.$HISTNB)

/* Send E-mail to recipients (as indicated) */
  n = G.$EMAIL.0
  do i = 1 to n
    email = G.$EMAIL.i
    if (email <> "") then call SendEmail(email)
    end

/* Mail Summary Report */
finish:
  call MailSummary

/* Remove temporary files */
  call CleanTempFiles

/* Exit Program */
done:
  exit

/*
  CheckBackup:  See if node has been backed up recently.
     return:
       0 - notification not wanted
       1 - negative notification wanted & recent backup occurred
       2 - positive notification wanted & recent backup occurred
       3 - notification wanted & no recent backup occurred
      (0,1) -> no notification to user
      (2,3) -> notify user (differently)

     The following arrays are filled in by this procedure:
       G.$NOCONTACT - list of nodes which have never contacted the server
       G.$LOCKED    - list of nodes which are locked
       G.$IGNORED   - list of nodes not wanting notification
       G.$NNBACKED  - list of nodes backed up recently, negative notify
       G.$PNBACKED  - list of nodes backed up recently, positive notify
       G.$NOTBACKED - list of nodes not backed up recently, wanting notify
       The following 2 FS. arrays are only filled in if a successful scheduled
       event was not found.
       FS.$BKP.node  = filespaces backed up recently
       FS.$NBKP.node = filespaces not backed up recently

  Notes:
    1. The term "negative notification" is used to indicate that the node
       owner wants to be notified only if a recent backup has not occurred.
    2. The term "positive notification" is used to indicate that the node
       owner wants to be notified always, whether a recent backup has 
       occurred or not.  However, the form of the notification will be
       different if a recent backup has occurred, than if a recent backup
       has not occurred.  
    3. The absolute value of NODE.node.$NOTIFY is used to determine whether 
       a "recent" backup has occurred or not.

  Logic:
    1. First we check EVENT.node.$COMPLETED to see if the last scheduled
       event for this node completed successfully or not.  If it did, then
       we check EVENT.node.$COMPLETE to see whether it completed recently
       or not.  If it occurred recently, then we return 1 or 2.
    2. If we don't see a successful scheduled event, then we revert to looking
       at the output from QUERY FILESPACE, to see when each filespace was
       last successfully completed.  At this point, we fill in the FS.$BKP
       and FS.$NBKP arrays.  We return 1, 2, or 3.

       Note that if we revert to step 2, then we may flag the node as not
       being successfully backed up because an obsolete filespace was not
       backed up (and normally wouldn't be by a scheduled backup).  Alas,
       we cannot determine this from the server, so we flag it anyway.
*/
CheckBackup: procedure expose G. F. FS. EVENT. NODE. NC.
  parse arg node .

  if (NODE.node.$PLATFORM="") then do  /* node has never contacted server */
    G.$NOCONTACT = G.$NOCONTACT node
    return 0
    end
  if (NODE.node.$LOCKED) then do       /* node is locked */
    G.$LOCKED = G.$LOCKED node
    return 0
    end
  if (NC.node.$NOTIFY = 0)
    then do                            /* node does not want to be notified */
    G.$IGNORED = G.$IGNORED node
    return 0
    end

  /* If scheduled backup completed recently, then return 1 or 2 */
  /* If positive notification wanted, return 2 */
  if (EVENT.node.$COMPLETED) then do
    parse value EVENT.node.$COMPLETE with cdate ctime .
    if (DeltaT(cdate ctime) < abs(NC.node.$NOTIFY)) then do
      if (NC.node.$NOTIFY < 0) then do
        G.$PNBACKED = G.$PNBACKED node
        return 2
        end
      else do
        G.$NNBACKED = G.$NNBACKED node
        return 1
        end
      end
    end

  /* If no scheduled backup completed recently, look at each filespace */
  n = FS.node.0
  do i = 1 to n   /* process each filespace for this node */
    f = FS.node.i
    /* If filesystem has not been backed up recently */
    if (LateBackup(node,f)) then do
      j=FS.$NBKP.node.0 + 1; FS.$NBKP.node.0=j; FS.$NBKP.node.j=f
      end
    else do
      j=FS.$BKP.node.0 + 1; FS.$BKP.node.0=j; FS.$BKP.node.j=f
      end
    end

  if (FS.node.0 = 0) then do          /* no filespaces exist; treat as  */
    G.$NOTBACKED = G.$NOTBACKED node  /*   if node was not backed up.   */
    return 3
    end
  if (FS.$NBKP.node.0 > 0) then do    /* node not backed up recently    */
    G.$NOTBACKED = G.$NOTBACKED node
    return 3
    end
  else do                             /* node backed up recently        */
    if (NC.node.$NOTIFY > 0) then do    /* negative notification wanted */
      G.$NNBACKED = G.$NNBACKED node
      return 1
      end
    else do                             /* positive notification wanted */
      G.$PNBACKED = G.$PNBACKED node
      return 2
      end
    end
  return ERROR

/*
  LateBackup:  determines if a backup is late or not.
    return:
       0 - if backup is not late
       1 - if backup is late 
*/
LateBackup: procedure expose G. F. EVENT. NODE. NC.
  parse arg node, filespace
  node=strip(node); filespace=strip(filespace)
  if ^(datatype(NC.node.$NOTIFY,W)) then return 0
  if (NC.node.$NOTIFY = 0)          then return 0
  if (F.$CDAYS.node.filespace = "") then return 1
  if (F.$CDAYS.node.filespace <= abs(NC.node.$NOTIFY)) then return 0
  return 1

/*
  DeltaT(date1,time1,date2,time2)
  date1,date2=mm/dd/yyyy
  time1,time2=hh:mm:ss

  returns #days between first date/time and second date/time.
          #days is not a whole number.
  if second date/time is not specified, the current date/time is used.
*/
DeltaT: procedure expose G.
  parse arg date1 time1 date2 time2 .

  if (date2="") 
    then parse value G.$NOW with date2 time2 .
  if (time2="") 
    then parse value G.$NOW with . time2 .

  parse value time1 with hh ":" mm ":" ss .
  if (ss="") then ss=0
  sec1=ss+(60*mm)+(3600*hh)
  base1=edate(B,date1,,L)+(sec1/(24*60*60))

  parse value time2 with hh ":" mm ":" ss .
  if (ss="") then ss=0
  sec2=ss+(60*mm)+(3600*hh)
  base2=edate(B,date2,,L)+(sec2/(24*60*60))

  return format(base2-base1,,2)

/* CleanTempFiles:  Remove any temporary files used by this script */
CleanTempFiles: procedure expose G.
  "/bin/test -d" G.$MAILDIR
  if (rc=0) then "/bin/rm -rf --" G.$MAILDIR
  return

/* MailSummary:  Mail Summary Report, if one was created. */
MailSummary: procedure expose G.
  call close G.$SUMMARY
  "/bin/test -f" G.$SUMMARY
  if (rc<>0) then return
  "/bin/cat" G.$SUMMARY ,
        "| /bin/mail -s ""ADSM Backup Summary Report""" G.$MAILTO
  return

/* PrepSummary:  Prepare Backup Summary Report */
PrepSummary: procedure expose G.
  file = G.$SUMMARY
  call output file "Summary Information:"
  call output file " "
  call output file "Nodes backed up and not notified:" ,
      format(words(G.$NNBACKED),3)
  call output file "Nodes backed up and notified:    " ,
      format(words(G.$PNBACKED),3)
  call output file "Nodes not backed up recently:    " ,
      format(words(G.$NOTBACKED),3)
  call output file "Nodes not wanting notification:  " ,
      format(words(G.$IGNORED),3)
  call output file "Nodes locked:                    " ,
      format(words(G.$LOCKED),3)
  call output file "Nodes never contacted server:    " ,
      format(words(G.$NOCONTACT),3)
  call output file " "
  return

/* PrepEmail:  Prepare mailfile for a node or set of nodes */
PrepEmail: procedure expose G. F. FS. NODE. NC. NL0. NL1. NL2. NL3. SUBJECT. ,
    EVENT.
  parse arg email

  /* Initialize some variables */
  file = G.$MAILDIR"/"email
  sumfile = G.$SUMMARY
  Ngood = words(NL2.email)
  Nbad  = words(NL3.email)

  /* If no notification is necessary, then we just return. */
  if (Ngood = 0) & (Nbad = 0) then return 1

  /* Set the "subject" */
  select
    when (Nbad = 0) & (Ngood = 1) then do
      subject = "ADSM has a recent backup for '"strip(NL2.email)"'"
      end
    when (Nbad = 0) & (Ngood > 1) then do
      subject = "ADSM has current backup for" Ngood "systems"
      end
    when (Nbad = 1) then do
      subject = "ADSM backup FAILED for '"strip(NL3.email)"'"
      end
    when (Nbad > 1) then do
      subject = "ADSM backup FAILED for" Nbad "of" Nbad+Ngood "systems"
      end
    otherwise do
      subject = "ADSM Backup Report"
      end
    end
  SUBJECT.email = subject

  /* Generate output for summary file */
  node = word(NL2.email NL3.email,1)
  name = NC.node.$ADMINNAME
  if (name = "") then name = NC.node.$OWNERNAME
  phone = NC.node.$ADMINPHONE
  if (phone = "") then phone = NC.node.$OWNERPHONE
  call output sumfile G.$SEPARATOR1
  call output sumfile "Short version of mail sent to" name "("phone"):"

  /* Prepare header for mailfile */
  l=""
  if ((Nbad + Ngood) = 1) then do
    this="this"
    system="system"
    is="is"
    end
  else do
    this="these"
    system="systems"
    is="are"
    end
  select
    when (Nbad = 1) & (Ngood = 0) then do
      n = strip(NL3.email)
      if (abs(NC.n.$NOTIFY) = 1)
        then x = "1 day"
        else x = abs(NC.n.$NOTIFY) "days"
      l=l "System '"n"' has NOT been backed up by the ADSM"
      l=l "Backup Server within the last" x"."
      l1 = "whenever this system is not backed up regularly."
      l2 = "this system"
      end
    when (Ngood = 1) & (Nbad = 0) then do
      n = strip(NL2.email)
      if (abs(NC.n.$NOTIFY) = 1)
        then x = "1 day"
        else x = abs(NC.n.$NOTIFY) "days"
      l=l "System '"n"' has been successfully backed up by the ADSM"
      l=l "Backup Server within the last" x"."
      l1 = "every day for this system."
      l2 = "this system"
      end
    when (Ngood = 0)  then do
      l=l "The following" Nbad "computer systems have NOT been backed up"
      l=l "recently by the ADSM Backup Server."
      l1 = "whenever these systems are not backed up regularly."
      l2 = "these systems"
      end
    when (Nbad = 0)   then do
      l=l "The following" Nbad "computer systems have been successfully"
      l=l "backed up recently by the ADSM Backup Server."
      l1 = "every day for these systems."
      l2 = "these systems"
      end
    otherwise do
      if (Ngood=1) then has="has"; else has="have"
      l=l Ngood "of the following computer systems" has "been successfully"
      if (Nbad=1) then has="has"; else has="have"
      l=l "backed up recently, and" Nbad "of the following computer systems"
      l=l has "NOT been backed up recently, by the ADSM Backup Server."
      l1 = "every day for at least one of these systems, or whenever some"
      l1=l1 "of these systems are not backed up regularly."
      l2 = "these systems"
      end
    end
  call paraout sumfile l
  l=l " You are listed as the administrator for" this system", and our"
  l=l "records indicate that you would like to receive this notification"
  l=l l1
  l=l " If you want to change the notification policy for"
  l=l l2", please send E-mail to" G.$MAILADMIN"."
  call paraout file l

  nn = NL3.email NL2.email
  do while (nn <> "")
    parse value nn with n nn
    call output file " "
    call output2 file sumfile G.$SEPARATOR2
    call output file " "
    rc = PrepNode(n, email, file, sumfile)
    end
  call output file " "
  call output file G.$SEPARATOR2
  return 0

/* PrepNode:  Prepare mailfile for node-admin */
PrepNode: procedure expose G. F. FS. NODE. NC. EVENT.
  parse arg node, email, file, sumfile

  l="System Name: " node
  if (NODE.node.$PLATFORM <> "") then l=l "  ("NODE.node.$PLATFORM")"
  call output2 file sumfile l

  if (NC.node.$OWNERNAME<>"") & (NC.node.$ADMINNAME<>"") & ,
        (NC.node.$OWNERNAME <> NC.node.$ADMINNAME)
    then do
      l="Owned by:    " NC.node.$OWNERNAME
      ll=""
      if (NC.node.$OWNERPHONE <> "") then ll = NC.node.$OWNERPHONE
      if (NC.node.$OWNEREMAIL <> "") then do
        if (ll <> "") then ll=ll","
        ll=ll NC.node.$OWNEREMAIL
        end
      if (ll<>"") then l=l "("ll")"
      call output2 file sumfile l
      end

  notify=NC.node.$NOTIFY
  anotify = abs(notify)
  if (abs(notify) > 1)
    then days = "days"
    else days = "day"
  if (notify > 0)
    then notifypolicy = "If not backed up for" notify days"."
    else notifypolicy = "Always notify."
  l="Notification:" notifypolicy
  call output2 file sumfile l

  platform = NODE.node.$PLATFORM
  select
    when (platform = "Mac") then do
      filespace  = "volume"
      filespace1 = "Volume name"
      end
    when (wordpos(platform,"OS/2 Windows DOS NetWare") > 0) then do
      filespace  = "drive"
      filespace1 = "Drive label"
      end
    when (wordpos(platform,"SunOS AIX ULTRIX HPUX SCO") > 0) then do
      filespace  = "filesystem"
      filespace1 = "Filesystem name"
      end
    otherwise do
      filespace  = "filespace"
      filespace1 = "Filespace name"
      end
    end

/*
  Need to distinguish between successful scheduled events vs manual backup!
  A successful scheduled event will have FS.$BKP.node.0 = 0.
  For a successful scheduled event, refer to EVENT.node.$COMPLETE
   EVENT.node.$COMPLETED = 0 | 1
   EVENT.node.$COMPLETE = <date> <time>
     <date> = mm/dd/yyyy  which backup successfully completed
*/
  c = EVENT.node.$COMPLETED
  parse value EVENT.node.$COMPLETE with cdate ctime
  t = FS.node.0
  n = FS.$NBKP.node.0
  b = FS.$BKP.node.0
  fsdetail = 1
  select
    when (n+b = 0) & (c = 1) then do      /* Scheduled Event completed */
      l="A scheduled backup HAS occurred within the last" anotify days
      l=l "for this system."
      l=l " The latest scheduled backup for this system was completed on"
      l=l cdate "at" ctime "("DeltaT(cdate ctime) "days ago)."
      fsdetail=0
      end
    when (t = 1) & (n = 0)
      then l="The only" filespace "for this system HAS been backed up" ,
          "within the last" anotify days":"
    when (t = 1) & (n = 1)
      then l="The only" filespace "for this system has NOT been backed up" ,
          "within the last" anotify days":"
    when (t > 1) & (n = 1)
      then l="1 of the following" t filespace"s has NOT been backed up" ,
          "within the last" anotify days":"
    when (t > 1) & (n = t) then do
      if (t=2) then x="Both"; else x="All"
      l=x "of the following" t filespace"s have NOT been backed up" ,
          "within the last" anotify days":"
      end
    when (t > 1) & (n > 1)
      then l=n "of the following" t filespace"s have NOT been backed up" ,
          "within the last" anotify days":"
    when (t > 0) & (n = 0) then do
      if (t=2) then x="Both"; else x="All" t
      l=x "of the" filespace"s for this system HAVE been backed up" ,
          "within the last" anotify days":"
      end
    when (t = 0) & (c = 0)
      then l="This system has NO backups at this time."
    otherwise
      l="The following" filespace"s were last backed up on the indicated dates:"
    end
  call paraout2 file sumfile l
  if (n > 0) then do                /* At least 1 filespace not backed up */
    call output2 file sumfile " "
    indent = "     "
    call output2 file sumfile ,
         indent left(filespace1,41) ,
         " "left("Last Backup Done",19) ,
         " "left("Days Ago",8)
    call output2 file sumfile ,
         indent copies("-",41)"  "copies("-",19)"  "copies("-",8)
    prefix = "     "
    do i = 1 to n
      filespace = FS.$NBKP.node.i
      lb = F.$CDATE.node.filespace
      if (lb = "") then lb = "Never"
      ld = F.$CDAYS.node.filespace
      if (ld = "") 
        then ld = "   N/A  "
        else ld = format(ld,6,1)
      call output2 file sumfile ,
           prefix left(filespace,41) ,
           " "left(lb,19) ,
           " "ld
      end  /* do i */
    m = FS.$BKP.node.0
    prefix = indent
    do i = 1 to m
      filespace = FS.$BKP.node.i
      lb = F.$CDATE.node.filespace
      if (lb = "") then lb = "Never"
      ld = F.$CDAYS.node.filespace
      if (ld = "") 
        then ld = "   N/A  "
        else ld = format(ld,6,1)
      call output2 file sumfile ,
           prefix left(filespace,41) ,
           " "left(lb,19) ,
           " "ld
      end
    end  /* then do ( >1 bad ) */
  call close file 
  return 0

/* SendEmail:  Send mail to node-administrator */
SendEmail: procedure expose G. NC. SUBJECT.
  parse arg email
  file=G.$MAILDIR"/"email
  subject = SUBJECT.email
  parse value email with y1 "@" y2
  if (y1 <> "") & (y2 = "") then email = email"@cornell.edu"
  call close file
  "/bin/test -f" file
  if (rc<>0) then return 0
  "/bin/cat" file "| /bin/mail -s """subject"""" email
  return 0

/* UpdateHistory:  Update History File */
UpdateHistory: procedure expose G.
  parse arg file .
  parse value G.$NOW with date time .
  line = edate(I,date,,L) ,
        right(words(G.$NNBACKED),5) ,
        right(words(G.$NOTBACKED),5) ,
        right(words(G.$IGNORED),5) ,
        right(words(G.$NOCONTACT),5) ,
        right(words(G.$LOCKED),5) ,
        right(words(G.$PNBACKED),5)
  call output file line
  return 0

/* UpdateNOBHistory:  Update NoBackupHistory File */
UpdateNOBHistory: procedure expose G.
  parse arg file .
  parse value G.$NOW with date time .
  line = edate(I,date,,L) G.$NOTBACKED
  call output file line
  return 0

output: procedure expose G.
  parse arg file line
  "/bin/test -f" file
  if (rc<>0) then do
    call lineout(file, "Output from ADSM Backup Monitor:")
    call lineout(file, "")
    end
  call lineout(file, line)
  return

output2: procedure expose G.
  parse arg file1 file2 line
  call output file1 line
  call output file2 line
  return

paraout: procedure expose G.
  parse arg file ll
  do while (ll<>"")
    n=words(left(ll,G.$WIDTH))
    l=subword(ll,1,n)
    if (length(l)>G.$WIDTH) then do
      n=n-1
      l=subword(ll,1,n)
      end
    ll=subword(ll,n+1)
    call output file l
    end
  return

paraout2: procedure expose G.
  parse arg file1 file2 ll
  call paraout file1 ll
  call paraout file2 ll
  return

close: procedure
  parse arg file .
  call lineout file 
  return

nocomma: procedure
  parse arg x .
  do forever
    parse value x with a "," b
    if (b = "") then return x
    x = a||b
    end
  return

datime: procedure
  parse arg d t .
  return "on" d "at" t

/* GetFilespaceInfo:  Get FILESPACE information from ADSM */
GetFilespaceInfo: procedure expose G. FS. F.
  FS. = 0  /* Filespace arrays.                                            */
           /* arrayname.0   = count; arrayname.i = element                 */
           /* FS.node       = filespaces for this node                     */
  F.  = "" /* Filespace data                                               */
           /* F.$SDAYS.node.filespace = # days since last backup started   */
           /* F.$CDAYS.node.filespace = # days since last backup completed */
           /* F.$SDATE.node.filespace = last backup start date/time        */
           /* F.$CDATE.node.filespace = last backup complete date/time     */
  call popen 'rxx adsmadm query filespace format=detailed' 
  do while (queued() > 0)
    pull x .
    if (x = "ANS5101I") then leave
    end

  do while (queued() > 0)
    parse pull tag ":" data
    if (data = "") then iterate
    data = strip(data)
    select
      when (tag="Node Name")                          then node = data
      when (tag="Filespace Name")                     then do
        filespace = data
        j=FS.node.0 + 1; FS.node.0=j; FS.node.j=filespace
        end
      when (tag="Platform")                           then nop
      when (tag="Filespace Type")                     then nop
      when (tag="Capacity (MB)")                      then nop
      when (tag="%Util")                              then nop
      when (tag="Last Backup Start Date/Time")        then do
        F.$SDATE.node.filespace = data
        F.$SDAYS.node.filespace = DeltaT(data)
        end
      when (tag="Days Since Last Backup Started")     then nop
      when (tag="Last Backup Completion Date/Time")   then do
        F.$CDATE.node.filespace = data
        F.$CDAYS.node.filespace = DeltaT(data)
        end
      when (tag="Days Since Last Backup Completed")   then nop
      otherwise do
        say "Unexpected response format from QUERY FILESPACE:" tag
        end
      end  /* select */
    end  /* do while queued */
  return 0

/*
  GetEventInfo:   Get Event information from ADSM

  EVENT.node.$COMPLETED = 0 | 1
  EVENT.node.$COMPLETE = <date> <time>
    <date> = mm/dd/yyyy  which backup successfully completed
    <time> = hh:mm:ss
*/

GetEventInfo: procedure expose G. EVENT.
  EVENT. = 0
  begindate=edate(U,,-2,L)
  begintime="00:00"
  enddate=edate(U,,,L)
  endtime="23:59"
  call popen 'rxx adsmadm query event "* *" format=detailed' ,
        'begind='begindate 'begint='begintime 'endd='enddate 'endt='endtime
  do while (queued() > 0)
    pull x .
    if (x = "ANS5101I") then leave
    end

  do while (queued() > 0)
    parse pull tag ":" data
    if (data = "") then iterate
    data = strip(data)
    select
      when (tag="Policy Domain Name")                 then nop
      when (tag="Schedule Name")                      then nop
      when (tag="Node Name")                          then node = data
      when (tag="Scheduled Start")                    then nop
      when (tag="Actual Start")                       then nop
      when (tag="Completed")                          then compdate = data
      when (tag="Status")                             then do
        status=upper(data)
        select
          when (status="COMPLETED")             then do
            EVENT.node.$COMPLETED = 1
            EVENT.node.$COMPLETE  = compdate
            end
          when (status="STARTED")               then nop
          when (status="RESTARTED")             then nop
          when (status="FUTURE")                then nop
          when (status="PENDING")               then nop
          when (status="UNCERTAIN")             then nop
          when (status="MISSED")                then nop
          when (status="FAILED")                then nop
          when (status="SEVERED")               then nop
          otherwise say "Unexpected Status from Q EVENT:" data
          end
        end
      when (tag="Result")                             then nop
      otherwise do
        say "WARNING: Unexpected response format from QUERY EVENT:" tag
        end
      end  /* select */
    end  /* do while queued */
  return 0

/* Last Updated: 7/21/95 */
/*includes asn1.rxx */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* GetNodeInfo and ParseContact are included from file GetNodeInfo.rxx */
/* GetNodeInfo:  Get Node Information from ADSM 

            NODE.node.$PLATFORM          Platform Type
            NODE.node.$REGISTERED        =1 if node ever contacted server
            NODE.node.$ACCESSDAYS        #days since last access
            NODE.node.$LOCKED            =1 if locked; =0 if not locked
            NODE.node.$COMPRESSION       Client | Yes | No
            NODE.node.$DOMAIN            Domain name
            NODE.node.$ARCHDEL           =1 if Yes; =0 if No
            NODE.node.$BACKDEL           =1 if Yes; =0 if No
            NC.node.$ACCOUNTTYPE         Account type (U,B,M,V,D)
            NC.node.$ACCOUNT             Account number
            NC.node.$OWNERNAME           Owner's name
            NC.node.$OWNEREMAIL          Owner's Email address
            NC.node.$OWNERPHONE          Owner's phone #
            NC.node.$ADMINNAME           Admin's name
            NC.node.$ADMINEMAIL          Admin's Email address
            NC.node.$ADMINPHONE          Admin's phone #
            NC.node.$ADMINCMAIL          Campus Mail Address
            NC.node.$NOTIFY              0 | #days to notify if no backup
            NC.node.$NOTIFYEMAIL         Email to send notification to
            NC.node.$EXPDATE             Date to delete node (yyyymmdd)
            NC.node.$REST                any unparseable information

   returns: <nodelist> - list of nodes which info was obtained for
*/
GetNodeInfo: procedure expose G. NODE. NC.
  parse arg node .

  nodelist = ""
  NODE.    = ""
  NC.      = ""
  
  rc = osd_ADSMQstack('query node "'node'" format=detailed')
  if ((rc <> 0) & (rc <> 11)) then do
    say "Aborting program..."
    exit 12
    end
  do while (queued() > 0)
    pull x .
    if (x = "ANS5101I") then leave
    end
  
  do while (queued() > 0)
    parse pull raw
    parse value raw with tag ":" data
    if (data = "") then iterate
    data = strip(data)
    select
      when (tag="Node Name")                          then do
        node = data
        nodelist = nodelist node
        end
      when (tag="Platform")                           then do
        if (data="(?)") then do
          NODE.node.$PLATFORM   = ""
          NODE.node.$REGISTERED = 0
          end
        else do
          NODE.node.$PLATFORM   = data
          NODE.node.$REGISTERED = 1
          end
        end
      when (tag="Policy Domain Name")                 then do
        NODE.node.$DOMAIN       = data
        end
      when (tag="Last Access Date/Time")              then nop
      when (tag="Days Since Last Access")             then do
        if (data = "<1") then data = 0
        NODE.node.$ACCESSDAYS = data
        end
      when (tag="Password Set Date/Time")             then nop
      when (tag="Days Since Password Set")            then nop
      when (tag="Locked?")                            then do
        if (data="No")
          then NODE.node.$LOCKED = 0
          else NODE.node.$LOCKED = 1
        end
      when (tag="Contact")                            then do
        data = substr(raw,33,47)
        if (substr(data,47,1)="-") then do
          b = ""
          data = substr(data,1,46)
          end
        else b = " "
        data = strip(data,T)
        do while (queued() > 0)
          parse pull next
          if (pos("Compression:",next)<>0)
            then do; push next; leave; end
            else do
              xdata=substr(next,34,46)
              if (substr(xdata,46,1)="-")
                then do
                  nextb = ""
                  xdata = substr(xdata,1,45)
                  end
                else nextb = " "
              data=data||b||strip(xdata,T)
              b = nextb
              end
          end
        call ParseContact node data
        end
      when (tag="Compression")                        then do
        udata=upper(data)
        select
          when(data="Client's Choice")   then data = "Client"
          when(abbrev("CLIENT",udata,1)) then data = "Client"
          when(abbrev("YES",udata,1))    then data = "Yes"
          when(abbrev("NO",udata,1))     then data = "No"
          otherwise say "Unexpected Compression value detected:" data
          end
        NODE.node.$COMPRESSION   = data
        end
      when (tag="Archive Delete Allowed?")            then do
        udata=upper(data)
        select
          when(abbrev("YES",udata,1))    then data = 1
          when(abbrev("NO",udata,1))     then data = 0
          otherwise say "Unexpected Archive Delete value detected:" data
          end
        NODE.node.$ARCHDEL       = data
        end
      when (tag="Backup Delete Allowed?")             then do
        udata=upper(data)
        select
          when(abbrev("YES",udata,1))    then data = 1
          when(abbrev("NO",udata,1))     then data = 0
          otherwise say "Unexpected Backup Delete value detected:" data
          end
        NODE.node.$BACKDEL       = data
        end
      when (tag="Registration Date/Time")             then nop
      when (tag="Registering Administrator")          then nop
      when (tag="Last Communication Method Used")     then nop  
      when (tag="Bytes Received Last Session")        then nop
      when (tag="Bytes Sent Last Session")            then nop
      when (tag="Duration of Last Session (sec)")     then nop  
      when (tag="Pct. Idle Wait Last Session")        then nop
      when (tag="Pct. Comm. Wait Last Session")       then nop
      when (tag="Pct. Media Wait Last Session")       then nop
      when (subword(tag,1,1)="ANR2034E")              then nop
      when (subword(tag,1,1)="ANS5102I")              then nop
      otherwise do
        say "Unexpected response format from QUERY NODE:" tag
        end
      end  /* select */
    end  /* do while queued */
  return nodelist

/* ParseContact:  Parse CONTACT field from QUERY NODE 
                  Following arrays are set by this function:
                  NC.node.$ACCOUNTTYPE = account type
                  NC.node.$ACCOUNT     = account
                  NC.node.$OWNERNAME   = name
                  NC.node.$OWNEREMAIL  = email
                  NC.node.$OWNERPHONE  = phone
                  NC.node.$ADMINNAME   = name
                  NC.node.$ADMINEMAIL  = email
                  NC.node.$ADMINPHONE  = phone
                  NC.node.$ADMINCMAIL  = campusmail
                  NC.node.$NOTIFY = 0 | #
                  NC.node.$NOTIFYEMAIL = notify-email
                  NC.node.$EXPDATE     = Date to delete node (yyyymmdd)
                  NC.node.$REST   = any unparseable information 
*/
ParseContact: procedure expose NC.
  parse arg node contact
  if (left(contact,1)="/") then do
    call ParseContactV2 node contact
    return
    end
  NC.node = ""; NC.node.$NOTIFY = 0
  fieldlist = contact
  do while (fieldlist <> "")
    parse value fieldlist with field ';' fieldlist
    parse value field with tag '=' data
    if (data = "") then do
      if (fieldlist<>"") then field=field";"
      say "Invalid Field """field""" found for node" node". CONTACT field:"
      say contact
      '/bin/sleep 5'
      NC.node.$REST = NC.node.$REST field 
      iterate
      end
    tag=upper(strip(tag)); data=strip(data);
    if (left(data,1)="(")                  /* strip off parens, if any */
      then data=substr(data,2)
    l=length(data)-1
    if (right(data,1)=")")
      then data=substr(data,1,l)
    select
      when (tag="$") then do
        NC.node.$ACCOUNT = data
        end
      when (abbrev("OWNER",tag,1)) then do
        parse value data with name "," email "," phone
        name=strip(name); email=strip(email); phone=strip(phone)
        parse value email with e1 "@" e2
        if (e1 <> "") & (e2 = "") then email = email"@cornell.edu"
        NC.node.$OWNERNAME  = name
        NC.node.$OWNEREMAIL = email
        NC.node.$OWNERPHONE = phone
/* --
        if (NC.node.$ADMINNAME="")  then NC.node.$ADMINNAME  = name
        if (NC.node.$ADMINEMAIL="") then NC.node.$ADMINEMAIL = email
        if (NC.node.$ADMINPHONE="") then NC.node.$ADMINPHONE = phone
-- */
        end
      when (abbrev("ADMIN",tag,1)) then do
        parse value data with name "," email "," phone
        parse value email with e1 "@" e2
        if (e1 <> "") & (e2 = "") then email = email"@cornell.edu"
        NC.node.$ADMINNAME  = strip(name) 
        NC.node.$ADMINEMAIL = strip(email) 
        NC.node.$ADMINPHONE = strip(phone)
        end
      when (abbrev("NOTIFY",tag,1)) then do
        select
          when (abbrev("ALWAYS",upper(data),1)) then NC.node.$NOTIFY = "-1"
          when ^(datatype(data,W))              then NC.node.$NOTIFY = 0
          otherwise                                  NC.node.$NOTIFY = data
          end
        end
      otherwise do
        say "Unknown Field TAG """tag""" found for node" node". CONTACT field:"
        say contact
        NC.node.$REST = NC.node.$REST field
        end
      end  /* select */
    end  /* do while */
  if (NC.node.$NOTIFYEMAIL = "") & (NC.node.$ADMINEMAIL <> "")
    then NC.node.$NOTIFYEMAIL = NC.node.$ADMINEMAIL
  if (NC.node.$ACCOUNT <> "") & (NC.node.$ACCOUNTTYPE = "")
    then NC.node.$ACCOUNTTYPE = "U"
  /* If Admin/Contact info not specified, set it to Owner info. */
  if (NC.node.$ADMINNAME  = "") & (NC.node.$OWNERNAME  <> "")
    then NC.node.$ADMINNAME = NC.node.$OWNERNAME
  if (NC.node.$ADMINPHONE = "") & (NC.node.$OWNERPHONE <> "")
    then NC.node.$ADMINPHONE = NC.node.$OWNERPHONE
  if (NC.node.$ADMINEMAIL = "") & (NC.node.$OWNEREMAIL <> "")
    then NC.node.$ADMINEMAIL = NC.node.$OWNEREMAIL
  return

/* ParseContactV2: Parse CONTACT field from QUERY NODE (Version 2)
   Version 2 uses ASN syntax for the Contact field.
                  Following arrays are set by this function:
                  NC.node.$ACCOUNTTYPE = account type
                  NC.node.$ACCOUNT     = account
                  NC.node.$OWNERNAME   = name
                  NC.node.$OWNEREMAIL  = email
                  NC.node.$OWNERPHONE  = phone
                  NC.node.$ADMINNAME   = name
                  NC.node.$ADMINEMAIL  = email
                  NC.node.$ADMINPHONE  = phone
                  NC.node.$ADMINCMAIL  = campusmail
                  NC.node.$NOTIFY = 0 | #
                  NC.node.$NOTIFYEMAIL = notify-email
                  NC.node.$EXPDATE     = Date to delete node (yyyymmdd)
                  NC.node.$REST   = any unparseable information 
*/
ParseContactV2: procedure expose NC.
  parse arg node contact
  if (left(contact,1) <> "/") then do
    say "ParseContactV2: Contact field is not a version level 2.  Aborting."
    say "node="node";contact="contact
    exit 12
    end
  NC.node = ""; NC.node.$NOTIFY = 0
  fieldlist = contact
  do while (fieldlist <> "")
    call GetField  /* Updates fieldlist.  Sets tag & data */
    select
      when (tag="/$") then do
        parse value data with x1 ":" x2
        NC.node.$ACCOUNTTYPE = x1
        NC.node.$ACCOUNT = x2
        end
      when (tag="/ON") then do
        NC.node.$OWNERNAME = data
        end
      when (tag="/OP") then do
        NC.node.$OWNERPHONE = data
        end
      when (tag="/OM") then do
        parse value data with e1 "@" e2
        if (e1 <> "") & (e2 = "") then data = data"@cornell.edu"
        NC.node.$OWNEREMAIL = data
        end
      when (tag="/CN") then do
        NC.node.$ADMINNAME = data
        end
      when (tag="/CP") then do
        NC.node.$ADMINPHONE = data
        end
      when (tag="/CC") then do
        NC.node.$ADMINCMAIL = data
        end
      when (tag="/CM") then do
        parse value data with e1 "@" e2
        if (e1 <> "") & (e2 = "") then data = data"@cornell.edu"
        NC.node.$ADMINEMAIL = data
        end
      when (tag="/N") then do
        parse value data with x1 ":" x2
        select
          when (abbrev("ALWAYS",upper(x1),1)) then NC.node.$NOTIFY = "-1"
          when ^(datatype(x1,W))              then NC.node.$NOTIFY = 0
          otherwise                                NC.node.$NOTIFY = x1
          end
        parse value x2 with e1 "@" e2
        if (e1 <> "") & (e2 = "") then x2 = x2"@cornell.edu"
        NC.node.$NOTIFYEMAIL = x2
        end
      when (tag="/X") then do
        NC.node.$EXPDATE = data
        end
      otherwise do
        say "Unknown Field TAG """tag""" found for node" node". CONTACT field:"
        say contact
        NC.node.$REST = NC.node.$REST field
        end
      end  /* select */
    end  /* do while */
  return
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/* asn1.rxx  Last Updated: 7/21/95 */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* GetField()    returns the next tag & data field of a field list.
                 The fieldlist is assumed to look as follows:
                 /tag1=field1/tag2=field2/tag3=field3 ...
                 NOTE: this procedure exposes tag, field, and fieldlist.
                       It is not passed args, nor does it return any!
*/
GetField: procedure expose G. tag data fieldlist
  tag = ""
  data = ""
  if (fieldlist = "") then do
    say "Warning: GetField() was called when fieldlist was empty."
    return 0
    end

  /* Get the next field from fieldlist, and update fieldlist */
  field = ""
  nfi = 1
  do until (field <> "") | (fieldlist = "")  /* look for start of next field */
    nfi = nfi + 1
    nfi = pos("/",fieldlist,nfi)
    select
      when (nfi = 0) then do                                /* no next field */
        field = strip(fieldlist)
        fieldlist = ""
        end
      when (substr(fieldlist,nfi+1,1) = "/") then do    /* skip double slash */ 
        nfi = nfi + 1
        end
      otherwise do                                  /* set field & fieldlist */
        field = strip(left(fieldlist,nfi-1))
        fieldlist = substr(fieldlist,nfi)
        end
      end  /* select */
    end  /* do until */

  /* Parse the field into its tag and data components */
  parse value field with tag '=' data
  tag = upper(strip(tag))
  data = UnslashData(data)
  return 0

/* SlashData(data) - returns data, with any embedded slashes doubled up */
SlashData: procedure expose G.
  parse arg dd
  r = ""
  do while (dd <> "")
    if (pos("/",dd)=0) then do
      r = r||dd
      dd = ""
      end
    else do
      parse value dd with d"/"dd
      r = r||d||"//"
      end
    end
  return r

/* UnslashData(data) - returns data, with any double slashes singled up */
UnslashData: procedure expose G.
  parse arg dd
  r = ""
  do while (dd <> "")
    if (pos("//",dd)=0) then do
      r = r||dd
      dd = ""
      end
    else do
      parse value dd with d"//"dd
      r = r||d||"/"
      end
    end
  return r

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* Operating System Dependent REXX Functions                                 */
/*                                                                           */
/* Do not edit these functions here.  These are copied in from source file   */
/* osd.rxx.  These routines are used by other, related, execs.  If you need  */
/* to change the way a routine works, make a copy of it and rename it to     */
/* avoid any potential confusion.                                            */
/*                                                                           */
/* It is intended that ALL operating system dependent functions should       */
/* be contained within functions that are sourced from osd.rxx, to make      */
/* porting to other platforms easier.                                        */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/* osd_CMD:      Issue command (directly, without a shell)                   */
/*               Return the return code issued by the command.               */
osd_CMD: procedure expose G.
  parse arg cmdstring
  address "command" cmdstring
  return RC

/* osd_CMDstack: Issue command, and queue response on stack.                 */
/*               Return the return code issued by the command.               */
osd_CMDstack: procedure expose G.
  parse arg cmdstring
  return popen(cmdstring)

/* osd_ADSMstack: Shortcut to call osd_ADSMcmd with stack option set.        */
osd_ADSMstack: procedure expose G.
  parse arg cmd, Aid, Apass, expected
  return osd_ADSMcmd(cmd, Aid, Apass,, 1)

/* osd_ADSMQstack: Issue ADSM QUERY command, and queue response on stack.    */
/*                 The ADSM ID and Password are either (1) passed to this    */
/*                 function, (2) obtained from global variables              */
/*                 G.$ADSMQID and G.$ADSMQPASS, or (3) prompted for from     */
/*                 the osd_ADSMstack function.                               */
osd_ADSMQstack: procedure expose G.
  parse arg cmd, Aid, Apass, expected
  select
    when ((Aid <> "") & (Apass <> "")) then nop
    when ((G.$ADSMQID <> "") & (G.$ADSMQID <> "G.$ADSMQID")) ,
        & ((G.$ADSMQPASS <> "") & (G.$ADSMQPASS <> "G.$ADSMQPASS")) then do
      Aid   = G.$ADSMQID
      Apass = G.$ADSMQPASS
      end
    otherwise do
      Aid   = ""
      Apass = ""
      end
    end
  rc = osd_ADSMcmd(cmd, Aid, Apass, 11, 1)
  return rc

/* osd_ADSMcmd: Issue ADSM command.  Return RC.  Optionally stack results.   */
/*                The ADSM AdminID and Password are either (1) passed to     */
/*                this function, (2) obtained from global variables          */
/*                G.$ADSMUSER and G.$ADSMPASS, or (3) prompted for.  If      */
/*                they are prompted for, they are saved in the global vars.  */
/*                'expected' is a list of expected return codes to not       */
/*                complain about.                                            */
/*                If 'stack' is non-null, then results are stacked.          */
osd_ADSMcmd: procedure expose G.
  parse arg cmd, Aid, Apass, expected, stack
  Aid = strip(Aid); Apass=strip(Apass)
  if (stack="") 
    then stack = 0
  else stack = 1

  do forever
    if ((Aid="") | (Apass="")) then do
      do while (G.$ADSMUSER="G.$ADSMUSER") | (G.$ADSMUSER="") ,
            |  (G.$ADSMPASS="G.$ADSMPASS") | (G.$ADSMPASS="")
        call osd_Clear
        say "In order to perform the requested function, you must enter your"
        say "ADSM userid and password."
        say ""
        call charout(,"ADSM administrator userid: ")
        parse upper pull G.$ADSMUSER .
        if (G.$ADSMUSER="QUIT") then exit 12
        if (G.$ADSMUSER="") then iterate
        G.$ADSMPASS = osd_GetMask("Password for this userid: ")
        end
      Aid   = G.$ADSMUSER
      Apass = G.$ADSMPASS
      end
    cmdstring = 'dsmadmc -id='Aid '-password='Apass cmd
    if (stack) then do
      q = queued()
      RC = osd_CMDstack(cmdstring)
      end
    else do
      say ""
      call osd_Clear
      RC = osd_CMD(cmdstring)
      end
    if (RC=53) | (RC=137) then do
      say "Invalid ADSM Userid and/or password was specified.  Re-try."
      Aid = ""
      G.$ADSMUSER = ""
      call osi_Continue
      iterate
      end
    if ((RC <> 0) & (wordpos(RC,expected) = 0)) then do
      exitRC = RC
      say "Unexpected return code ("exitRC") occurred from following command:"
      say cmdstring
      call osi_Continue
      return exitRC
      end
    leave
    end
  return RC

/* osd_Clear: Clear Screen.                                                  */
osd_Clear: procedure
  '/bin/clear'
  return 0

/* osd_Sleep: Sleep for N seconds (default N=1).                             */
osd_Sleep: procedure
  parse arg n .
  if (n="") then n=1
  '/bin/sleep' n
  return 0

/* osd_NSlookup: Determine if host is registered in DNS.                     */
/*               If host is not registered, return 0.                        */
/*               If host IS registered, return full hostname & IP address.   */
osd_NSlookup: procedure expose G.
  parse arg host .
  q=queued()
  response=""
  rc = osd_CMDstack('/bin/nslookup' host)
  do while (queued() > q)
    parse pull x
    response=response x
    end
  parse value response with "Name:" xrest
  parse value xrest with hostname .
  parse value xrest with "Address:" address .
  if (hostname="") then return 0
  return hostname address

/* osd_GetMask: Issue prompt and get response.  Response is masked, as is    */
/*              appropriate for prompting for a password.                    */
osd_GetMask: procedure
  parse arg prompt
  call charout(,prompt)          /* Issue prompt, without carriage return.   */
  '/bin/stty -echo'              /* Turn off character echoing               */
  parse pull answer .
  '/bin/stty echo'               /* Turn on character echoing                */
  say ""
  return answer

/* osd_DeleteFile: Delete a file.                                            */
osd_DeleteFile: procedure 
  parse arg file
  '/bin/rm' file
  return 0

/* osd_DBget: Get record(s) from database which match key; return # records. */
osd_DBget: procedure
  parse arg database, key
  /* not written yet */
  return 0

/* osd_DBput: Write record to database which has key.                        */
osd_DBput: procedure
  parse arg database, key, data
  /* not written yet */
  return 0

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* Operating System Independent REXX Functions                               */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/* osi_Continue:                                                             */
osi_Continue: procedure
  say ""
  say "Press ENTER to continue..."
  pull x
  return

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

/*
   Legal Information:

   Although copyrighted, this software is being licensed to you for your
   use free of charge.  However, ownership of and interest in this software
   shall remain with the author.  Use and distribution of this software is
   governed by the following terms.

   This software is owned by the author and contains valuable and 
   proprietary information of the author.  If you violate any part of this
   agreement, your right to use this software terminates automatically.
   In the event of termination of this agreement, you must destroy all copies
   of this software and derivatives of this software in your possession and
   cease distributing the same.

   This software is being licensed to you as provided by the terms of this
   agreement.

   You may:
   1.  Use this software on as many computers as you want at any given time.
   2.  Make as many backup copies of this software as you want.
   3.  Alter the software in any manner you see fit FOR YOUR OWN PERSONAL
       USE.  Such altered versions should not be distributed.  The creation
       of such derivatives shall not diminish the author's title to this
       software.
   4.  Terminate this agreement at any time by destroying all copies of this
       software and derivatives of this software and cease distributing the
       same.

   You may not:
   1.  Create any derivative works from this software for distribution.
   2.  Re-distribute this software for commercial (for-profit) purposes.

   Contact the author at the address within this document if you wish to
   distribute this software for commercial usage, or if you have any
   questions about its redistribution.

   Disclaimer of warranty:
   In using this software, you understand and agree that this software is
   provided "as is" without warranty of any kind.  The entire risk as to the
   results of and performance of using this software lies entirely with you,
   the user.  The author does not make any warranties, either expressed or
   implied, including but not limited to implied warranties of merchantability
   and fitness for a particular purpose, with respect to this software.

   In no event shall the author be liable for any consequential, incidental,
   or special damages whatsoever arising out of the use or inability to use
   this software.

*/