/*****************************************************************************/
/*
                                 screper.c

... a terminal screen screper, er scréper, um scraper.



HOW IT WORKS
------------
Getting the VT100-style terminal output of a "regular" command-line application
onto a browser HTML page.  The parent application (script) using an
XMLHttpRequest() activates a wrapper for the routines in this module.  This
spawns a subprocess which initiates the commnd-line application and a screen of
terminal output is generated.

This output is parsed with VT100/ANSI cursor, character attributes, and other
sequences, building a virtual, in-memory screen.  This generates HTML markup to
represent the screen in a browser.  The HTML is streamed as a response to the
XMLHttpRequest() with the "snapshot" representing each terminal screen.

A stream is a series of time-based snapshots.  The idea is that a screen is
built from output fairly quickly, and may have a well-defined update rate.  The
snapshotter ticks ten times a second and when the virtual screen has not
received new display data for the specified number of ticks a snapshot of that
virtual screen (in HTML markup) is sent to the parent running in the browser. 
For example, the MONITOR update rate is roughly 6 seconds.  So a snapshot value
of one-tenth second ticks of 55 will snapshot after 5.5 seconds of MONITOR
quiesence.  Just enough not to update too frequently but not to update in the
middle of new data being received.  There is probably a sweetspot for each
update interval and application.  This time-based approach is not suitable for
continuously or randomly updating screens, and congested systems can result in
partial or broken displays.

An alternative to a time-based update is to trigger a snapshot on the detection
of unique octet sequence.  For example, if the clear-screen CSI sequence is
used to begin a fresh screen display then the octet sequence, 0x1b 0x5b 0x32
0x4a, then detecting this in the terminal output can be used to generate a
snapshot before the output is sent to to scraper for processing.  Such a
sentinal must be terminated by 2 null characters.  Multiple sentinals can be
inside the string by separating each with a single null.  Obviously a null
character cannot be used as part of the sentinal.  To be detected a sentinal
must be self-contained in a single output record.  Here is an example os a
single sentinal string.

   uchar example [] = { 0x1b, 0x5b, 0x32, 0x4a, 0x00, 0x00 };



SCREPER DOES NOT PRETEND
------------------------
to be an exhaustive VT terminal interpreter.  The development baseline
application was the MONITOR utility.  Screper seems to handle MONITOR with
considerable aplomb.  However, no little wonder that terminal emulator authors
seldom get it 100% and quickly move on to something else.



SCREPER API
-----------
ScreperInit() returns a pointer to an opaque structure (void*).

ScreperDone() deallocates memory used during processing and returns a NULL.

ScreperDo() is supplied a string which is processed to set parameters and/or
perform a DCL command.  Directives must be lower case, include at least the
first three characters, and have no white space between the directive, equate
symbol, and value.  Some can only be used standlone.  A single or multiple
calls may be made to set up the virtual terminal session.  The final call must
contain the DCL commands.

-7bit                    terminal 7 bits
-8bit                    terminal 8 bits (default)
-dcl=<string>            DCL command(s) (to end of line)
-device=<integer>        e.g. value from ttdef.h (default TT$_VT100)
-noerror                 do not detect -E- status and exit
-ctrlz                   supply a ^Z to the DCL command (also see -input)
-eot                     force send an EOT (subprocess not restarted)
-ext                     force send an EXT (subprocess is restarted)
-exit="<string>"         a string when matched in output triggers an exit
-noeot                   do not send an EOT
-noext                   do not send an EXT
-nofatal                 do not detect -F- status and exit
-input="<string>"        supply this string as input to the command
-inspect=<integer>       inspect the data stream at various levels
-page=[+]<integer>       number of lines on page (24..255)
-noecho                  do not echo the command
-noprogress=<integer>    if output stalls for this many seconds (default 30)
-repeat=<integer>        repeat every <integer> seconds
-sentinal="<string>"     when output contains this it triggers a snapshot
-scroll                  .scrollIntoView()
-snapshot=<integer>      tenths of a second before snapshot (-n, 0, 5..600)
-timestamp[="<string>"]  begin the display with a timestamp
-utility="<string>"      name of the utility displayed with the pause button
-wait[=<integer>]        hibernate (sleep) seconds (default is forever)
-nowarn                  do not detect -W- status and exit
-width=<integer>         width of line, 80 or 132 ... 255 chars (default 80)

-css                     return style sheet
-javascript              return JavaScript
-pause                   return HTML for a "pause all" button
-resize                  return JavaScript to resize an iframe
-screen                  return HTML providing virtual screen
-version                 return version as string (standalone)

The -input string, along with the -sentinal and -timestamp strings, must be
quotation character delimited, and can include control codes and other "exotic"
characters using the ^xx escape syntax. So inputing a control-Z would be ^1a, a
literal hat character ^3e, and literal quotation ^22.

The -timestamp has a default VMS date-time.  A format string may be supplied
allowing VMS date/time formatting (e.g. "!8%T", "!20%D") or strftime()
formatting (e.g. "%c", "%A, %B %d, %Y").  Other characters and HTML markup may
lead and trail the string formatting but the characters '!' and '%' are
considered reserved and introduce the format string.  HTML-entify if required
as literals.

See example applications for usage.



INTERNAL SENTINALS
------------------
Various "states" are communicated from the DCL commands strings using
shebang-commented sentinal strings that are detected and acted upon by spawned
output stream processor, as well as in the reverse direction, from the
HTML-ified terminal output stream to the JavaScript browser page "hidden" in
HTML-comment braces.

All DCL sentinals begin with the longword "!~!~", in part making them cheaper
to detect in the stream.  All HTML-embedded sentinals occur as HTML-commented
abbreviations (e.g. <!-- EOT -->).  Not all entinals are present in both DCL
and HTML streams.

EOT, ETX, STX and SYN are used for various purposes.

STX sentinal marks the start of meaningful output.  Up until the STX
sentinal is detected output from the spawned terminal session is ignored.

EOT sentinal indicates the spawning script should exit gracefully leaving
the HTML page intact on the browser.

ETX sentinal indicates the end of the current screen's output and the spawning
script should wait for another screenful.

The terminal session periodically send SYN sentinals (as <!-- SYN -->) to keep
the script output from no-progress timeout.



OPCOM
-----
Sometimes it is difficult to get meaningful (debug) data from this sort of
application.  The ScreperOpcom() function may be used to generate messages
containing basically anything useful.  The application executable must be
installed with /PRIVILEGE=OPER in addition to anything else required.



RESOURCES
---------
https://vt100.net/
https://vt100.net/docs/vt100-ug/chapter3.html
https://vt100.net/docs/vt510-rm/chapter7.html
http://fileformats.archiveteam.org/wiki/DEC_Special_Graphics_Character_Set
https://en.wikipedia.org/wiki/VT100_encoding
https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP
https://en.wikipedia.org/wiki/Content_Security_Policy



COPYRIGHT
---------
Copyright (C) 2021-2023 Mark G.Daniel

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.



VERSION LOG
-----------
06-OCT-2022  MGD  v1.1.0, CSP same-origin 'strict-dynamic' constraints
                          noprogress and error processing means LOTS more timers
                          -exit is now -ctrlz
                          major changes to internal subprocess processing
01-AUG-2021  MGD  v1.0.0, initial
*/
/*****************************************************************************/

#define SOFTWAREVN "v1.1.0"
#define SOFTWARENM "SCREPER"
#ifdef __ALPHA
#  define SOFTWAREID SOFTWARENM " " SOFTWAREVN " AXP"
#endif
#ifdef __ia64
#  define SOFTWAREID SOFTWARENM " " SOFTWAREVN " IA64"
#endif
#ifdef __x86_64
#  define SOFTWAREID SOFTWARENM " " SOFTWAREVN " X86"
#endif

#include <ctype.h>
#include <descrip.h>
#include <errno.h>
#include <fcntl.h>
#include <in.h>
#include <ints.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <stat.h>
#include <time.h>
#include <unistd.h>
#include <unixio.h>

#include <dvidef.h>
#include <iodef.h>
#include <iosbdef.h>
#include <jpidef.h>
#include <libdef.h>
#include <lib$routines.h>
#include <opcdef.h>
#include <starlet.h>
#include <ssdef.h>
#include <syidef.h>
#include <ttdef.h>
#include <tt2def.h>

#include "screper.h"

#define FI_LI "SCREPER",__LINE__

#define DC$_TERM 6

#ifndef UINT64PTR
/* mainly to allow easy use of the __unaligned directive */
#define UINTPTR __unaligned unsigned int*
#define ULONGPTR __unaligned unsigned long*
#define USHORTPTR __unaligned unsigned short*
#define UINT64PTR __unaligned uint64*
#define INT64PTR __unaligned int64*
#endif

/*
    Each cursor position in the virtual screen is 32 bits deep.

     0              7 8             15 16            23 24            31
    |................|................|................|................|
    |   8 bit char   |    SGR bits    |    G0 alpha    |    G1 alpha    |

                                       (these two fields are extravagant)
*/

#define SGR_BOLD  0x00000100
#define SGR_UNDER 0x00000200
#define SGR_BLINK 0x00000400
#define SGR_REVER 0x00000800
#define SGR_RESET 0x00004000
#define SGR_G1    0x00008000

#define CHAR_MASK 0x000000ff
#define SGR_MASK  0x0000ff00
#define G0_MASK   0x00ff0000
#define G1_MASK   0xff000000

#define MAX_PAGE  255
#define MAX_WIDTH 255

#define BUTTON_PAUSE      "|&thinsp;|"
#define BUTTON_UNPAUSE    ">>"
#define BUTTON_PAUSEALL   "Pause All"
#define BUTTON_UNPAUSEALL "Resume All"

#define DEFAULT_NO_PROGRESS 30

#define DELTA64_100_MSEC ((int64)-1000000)
#define DELTA64_ONE_SEC  ((int64)-10000000)

static ulong SentLong;
char SentEOT [16];
char SentETX [16];
char SentSTX [16];

static ulong PromptLong;
static int  CliPromptLength;
static char  CliPrompt [16];

static int64  etxTimer64 = DELTA64_ONE_SEC;
static int64  noProgTimer64 = DELTA64_ONE_SEC;
static int64  snapTimer64 = DELTA64_100_MSEC;
static int64  synTimer64 = DELTA64_ONE_SEC * 60;

static char  SoftwareId [] = SOFTWAREID;

#  define CSAVE_MAX 16
#pragma __member_alignment __save
#pragma __member_alignment

static struct ScreperStruct
{
   int  AnsiMode,
        CharTableG0,
        CharTableG1,
        CurSave,
        EfnRead,
        FontSize,
        InputLength,
        InspectStream,
        LibSpawnStatus,
        NoEcho,
        NoEOT,
        NoETX,
        NoError,
        NoFatal,
        NoPrompt,
        NoProgressSecs,
        NoWarning,
        PtdBits8,
        PtdDevice,
        PtdPageLength,
        PtdPagePlus,
        PtdPageWidth,
        PtdReadAst,
        PtdReadStatus,
        PtdWriteStatus,
        RepeatCount,
        RepeatSecs,
        RespondLength,
        ScreenBufferSize,
        ScreenCol,
        ScreenRow,
        ScrollIntoView,
        ScrolledCount,
        SendEOT,
        SendETX,
        SentDetected,
        SgrBlink,
        SgrBold,
        SgrEoj,
        SgrGrone,
        SgrReverse,
        SgrG1,
        SgrShot1,
        SgrUnder,
        SnapshotDataCount,
        SnapshotSentinalLength,
        SnapshotTenths,
        SpecGraphMode,
        StxDetected,
        TimeStampLength,
        UtilityLength,
        WaitSecs;

   int  ColSave [CSAVE_MAX],
        RowSave [CSAVE_MAX],
        SgrSave [CSAVE_MAX];

   int64  EotScrPtr,
          SnapScrPtr,
          SynScrPtr,
          TmoScrPtr;

   ulong  LibSpawnPid,
          ScriptJpiPid;

   ulong  inadr [2];
   ulong  chbuf [3];

   ushort  PtdChan;

   char  DclBuffer [512],
         InputBuffer [64],
         PrcNam [16],
         PtdDevName [64],
         ExitBuffer [128],
         ScriptPidString [16],
         SgrBuffer [128],
         SnapshotSentinal [64],
         TimeStamp [64],
         Utility [64];

   char  *CspHeader,
         *CspNonce,
         *JavaScriptPage,
         *JavaScriptPause,
         *JavaScriptResize,
         *NextWritePtr,
         *PtdReadBuffer,
         *PtdWriteBuffer,
         *RepeatCmdPtr;

   FILE  *ScrOut;

   ulong  *ScreenBuffer;

} ScreperStruct;

typedef struct ScreperStruct SCREPER_STRUCT;

#pragma __member_alignment __restore

#define PTD_READ_SIZE  18 * 512
#define PTD_WRITE_SIZE  2 * 512
#define PTD_BUFFER_PAGES 20

/* private prototypes */
static int PtdDollarWrite (ushort, char*, int);
static void PtdNoProgress (int64*);
static void PtdPoof (SCREPER_STRUCT*, int);
static void PtdRead (SCREPER_STRUCT*);
static void PtdScreperEot (int64*);
static void PtdScreperSyn (int64*);
static int PtdSpawn (SCREPER_STRUCT*);
static void PtdSpawnAst (SCREPER_STRUCT*);
static int PtdWrite (SCREPER_STRUCT*);

static char* ScreenChar (SCREPER_STRUCT*, ulong);
static char* ScreperCSP (void*);
static void ScreenCursor (SCREPER_STRUCT*, char*, ...);
static void ScreenDump (SCREPER_STRUCT*, char*, int);
static void ScreenIndex (SCREPER_STRUCT*, int*, int*);
static void ScreenNextLine (SCREPER_STRUCT*, int*, int*);
static void ScreenReverseIndex (SCREPER_STRUCT*, int*, int*);
static char* ScreperBegin (SCREPER_STRUCT*);
static void ScreperData (SCREPER_STRUCT*, char*, int);
static void ScreperDump (SCREPER_STRUCT*, char*, int);
static char* ScreperHtmlEncode (char*);
static void ScreperKnown (SCREPER_STRUCT*, char*, char*, char*);
static void ScreperMore (SCREPER_STRUCT*, char*, int);
static void ScreperPrint (SCREPER_STRUCT*, char*, int);
static void ScreperUnknown (SCREPER_STRUCT*, char*, char*, char*);
static void ScreenOutput (SCREPER_STRUCT*);
static char* ScreperPauseAll ();
static char* ScreperScreen ();
static void ScreenReport (SCREPER_STRUCT*, char*, ...);
static void ScreenReset (SCREPER_STRUCT*);
static void ScreenScrape (SCREPER_STRUCT*, char*, int);
static int ScreenSentinal (SCREPER_STRUCT*, char*, int);
static void ScreenSnapshot (int64*);
static void ScreenTimeStamp (SCREPER_STRUCT*);

static char* ConfigString (char*, char*, int, int*);

/*************/
/* code page */
/*************/

static char  *CharTable_0_31 [32] = {
".", ".", ".", ".", ".", ".", ".", ".", 
".", ".", ".", ".", ".", ".", ".", ".", 
".", ".", ".", ".", ".", ".", ".", ".", 
".", ".", ".", ".", ".", ".", ".", "." 
};

static char  *CharTable_32_94 [63] = {
" ", "!", "\"", "#", "$", "%", "&amp;", "'", 
"(", ")", "*", "+", ",", "-", ".", "/", 
"0", "1", "2", "3", "4", "5", "6", "7", 
"8", "9", ":", ";", "&lt;", "=", "&gt;", "?", 
"@", "A", "B", "C", "D", "E", "F", "G", 
"H", "I", "J", "K", "L", "M", "N", "O", 
"P", "Q", "R", "S", "T", "U", "V", "W", 
"X", "Y", "Z", "[", "\\", "]", "^"
};

static char  *CharTable_95_127 [33] = {
"_", 
"`", "a", "b", "c", "d", "e", "f", "g", 
"h", "i", "j", "k", "l", "m", "n", "o", 
"p", "q", "r", "s", "t", "u", "v", "w", 
"x", "y", "z", "{", "|", "}", "~", "" 
};

/* special graphics */
static char  *CharTable_SG_95_127 [33] = {
"&nbsp", "&diams;", "&blk14;", "&rarrb;", "&ddarr;", "&rarrb;", "&ddarr;", "&deg;", "&plusmn;",
"&LeftTeeArrow;", "&DownTeeArrow;", "&boxul;", "&boxdl;", "&boxdr;", "&boxur;", "&boxvr;", "&boxh;",
"&boxh;", "&boxh;", "&boxh;", "&boxh;", "&boxvr;", "&boxvl;", "&boxhu;", "&boxhd;",
"&boxv;", "&le;", "&ge;", "&pi;", "&ne;", "&pound;", "&bull;" 
};

static char  *CharTable_128_255 [128] = {
"&#xc4;", "&#xc5;", "&#xc7;", "&#xc9;", "&#xd1;", "&#xd6;", "&#xdc;", "&#xe1;", 
"&#xe0;", "&#xe2;", "&#xe4;", "&#xe3;", "&#xe5;", "&#xe7;", "&#xe9;", "&#xe8;", 
"&#xdd;", "&#xb0;", "&#xa2;", "&#xa3;", "&#xa7;", "&#xb8;", "&#xb6;", "&#xdf;", 
"&#xae;", "&#xa9;", "&#x2122;", "&#xb4;", "&#xa8;", "&#x2260;", "&#xc6;","&#xd8;", 
"&#xd7;", "&#xb1;", "&#x2264;", "&#x2265;", "&#xa5;", "&#xb5;", "&#xb9;", "&#xb2;", 
"&#xb3;", "&#x3c0;", "&#xa6;", "&#xaa;", "&#xba;", "&#x2592;", "&#xe6;", "&#xf8;", 
"&#xbf;", "&#xa1;", "&#xac;", "&#xbd;", "&#x192;", "&#xbc;", "&#xbe;", "&#xab;", 
"&#xbb;", "&#x2026;", "&#xfffd;", "&#xc0;", "&#xc3;", "&#xd5;", "&#x152;", "&#x153;", 
"&#x2013;", "&#x2014;", "&#x2518;", "&#x2510;", "&#x250c;", "&#x2514;", "&#xf7;", "&#x25c6;", 
"&#xff;", "&#x178;", "&#x253c;", "&#x20ac;", "&#xd0;", "&#xf0;", "&#xde;", "&#xfe;", 
"&#xfd;", "&#xb7;", "&#x23ba;", "&#x23bb;", "&#x2500;", "&#xc2;", "&#xca;", "&#xc1;", 
"&#xcb;", "&#xc8;", "&#xcd;", "&#xce;", "&#xcf;", "&#xcc;", "&#xd3;", "&#xd4;", 
"", "&#xd2;", "&#xda;", "&#xdb;", "&#xd9;", "&#x23bc;", "&#x23bd;", "&#x251c;", 
"&#2524;", "&#x2534;", "&#x252c;", "&#x2502;", "", "", "", ""
};

/**************/
/* JavaScript */
/**************/

static char  PageJavaScript [] =
"<script>\n\
\
var afterNetError = 60*1;\n\
var timeBegin = new Date();\n\
var beforeRefresh = 2;\n" /* Mbytes */
"var borderlw = '1px white dotted';\n\
var borderlg = '1px dimgray dotted';\n\
var bytesLoaded = 0;\n\
var bytesRefresh = 0;\n\
var eot = false\n\
var etx = false\n\
var networkError = false;\n\
var nul = false;\n\
var prevBytesLoaded = 0;\n\
var retryInterval = 1000*2;\n\
var screperConnected = false;\n\
var screperPaused = false;\n\
var screperScreen;\n\
var scrollIntoView = 0;\n\
var xhr;\n\
\n\
window.addEventListener('load',doScreper,false);\n\
\n\
function doScreper() {\n\
   var url = window.location.search;\n\
   if (url == '')\n\
      url = window.location.href + '?populate=1';\n\
   else\n\
      url = window.location.href + '&populate=1';\n\
   xhr = new XMLHttpRequest();\n\
   xhr.open('GET', url, true);\n\
   networkError = false;\n\
   bytesLoaded = prevBytesLoaded = 0;\n\
   bytesRefresh = beforeRefresh * 1000000 + getRandomInt(5000,15000);\n\
   screperScreen = document.getElementById('screperScreen');\n\
   if (!frameElement) {\n\
      while (screperScreen.firstChild)\n\
         screperScreen.removeChild(screperScreen.firstChild);\n\
   }\n\
   updateStatus('loading&hellip;');\n\
\n\
   xhr.onabort = function() {\n\
      if (eot) return;\n\
      if (!screperPaused) setTimeout(doScreper,getRandomInt(2000,3500));\n\
      screperConnected = false;\n\
   };\n\
\n\
   xhr.onload = function() {\n\
      if (eot) return;\n\
      if (!screperPaused) setTimeout(doScreper,getRandomInt(2000,3500));\n\
      screperConnected = false;\n\
   };\n\
\n\
   xhr.onerror = function(err) {\n\
      screperConnected = false;\n\
      networkError = true;\n\
      if (bytesLoaded > 255) {\n\
         screperScreen.style.borderLeft = borderlg;\n\
         updateStatus('<span class=\"error\">network error</span>');\n\
      }\n\
      setTimeout(doScreper,retryInterval);\n\
      retryInterval *= 2;\n\
      if (retryInterval > 1000*60) retryInterval = 1000*60;\n\
   };\n\
\n\
   xhr.onprogress = function(event) {\n\
      var begin, code, endof;\n\
      bytesLoaded = event.loaded;\n\
      if (bytesLoaded) {\n\
         nul = false;\n\
         var chunk = xhr.response.substring(prevBytesLoaded);\n"

/*
~~~~~~~~~~~~~~~~~~~~
Detect a "remote" JavaScript execution request generated by the terminal output
data stream.  A commented "<!-- $set(..) -->" sentinal triggers code to extract
the string contained by it and pass that to the doit() function for "effective"
execution (remebering eval() is not available under 'strict-dynamic' CSP).
*/

"       while ((begin = chunk.indexOf('<!-- $set')) >= 0) {\n\
            endof = chunk.indexOf(') -->\\n');\n\
            code = chunk.substring(begin+6,endof+1);\n\
            chunk = chunk.substring(0,begin) + chunk.substring(endof+6);\n\
           doit (code);\n\
         }\n\
\
         length = -1;\n\
         if ((length = chunk.search('<!-- EOT -->')) >= 0)\n\
            eot = true;\n\
         else \n\
         if ((length = chunk.search('<!-- ETX -->')) >= 0)\n\
            etx = true;\n\
         if (length >= 0) chunk = chunk.substr(0,length);\n\
\
         if (chunk.length && !screperPaused && !pauseAll()) {\n\
            screperScreen.innerHTML = chunk;\n\
            screperScreen.style.borderLeft = borderlw;\n\
            resizeIframe();\n\
         }\n\
\
         updateStatus('');\n\
         if (eot) return;\n\
\
         retryInterval = 1000*2;\n\
      }\n\
      prevBytesLoaded = bytesLoaded;\n\
      screperConnected = true;\n\
      if (bytesLoaded > bytesRefresh) xhr.abort();\n\
      if (scrollIntoView > 0) screperScreen.scrollIntoView(false);\n\
   };\n\
\n\
   xhr.send();\n\
}\n\
\n\
function doit(code) {\n\
   if (code.substring(0,10) == 'setCommand') {\n\
      var p1 = code.substring(11,code.length-1);\n\
      setCommand(p1);\n\
      return;\n\
   }\n\
   if (code.substring(0,11) == 'setFontSize') {\n\
      var p1 = code.substring(12,code.length-1);\n\
      setFontSize(p1);\n\
      return;\n\
   }\n\
   if (code.substring(0,16) == 'setScrolledCount') {\n\
      var p1 = code.substring(17,code.length-1);\n\
      scrolledCount(p1);\n\
      return;\n\
   }\n\
   if (code.substring(0,17) == 'setScrollIntoView') {\n\
      var p1 = code.substring(18,code.length-1);\n\
      scrollIntoView = p1;\n\
      return;\n\
   }\n\
   if (code.substring(0,10) == 'setUtility') {\n\
      var p1 = code.substring(11,code.length-1);\n\
      setUtility(p1);\n\
      return;\n\
   }\n\
}\n\
\n\
function scrolledCount(string) {\n\
   document.getElementById('screperScrolled').innerHTML = string + \
' lines scrolled off top';\n\
}\n\
\n\
function updateStatus(string) {\n\
   document.getElementById('screperStatus').innerHTML = string;\n\
}\n\
\n\
function pauseResume() {\n\
   if (screperPaused) {\n\
      document.getElementById('pauseButton').innerHTML = '"
BUTTON_PAUSE "';\n\
      if (!screperConnected) setTimeout(doScreper,getRandomInt(500,1500));\n\
   }\n\
   else\n\
      document.getElementById('pauseButton').innerHTML = '"
BUTTON_UNPAUSE "';\n\
   screperPaused = !screperPaused;\n\
}\n\
\n\
function pauseAll() {\n\
   if (parent && frameElement && parent.pauseAll) \
return window.parent.pauseAll();\n\
   return false;\n\
}\n\
\n\
function getRandomInt(min,max) {\n\
   min = Math.ceil(min);\n\
   max = Math.floor(max);\n\
   return Math.floor(Math.random() * (max - min + 1)) + min;\n\
}\n\
\n\
function resizeIframe() {\n\
   if (parent && frameElement && parent.resizeIframe) {\n\
      var width = document.body.scrollWidth + 10;\n\
      var height = document.body.scrollHeight + 15;\n\
      parent.resizeIframe(window.frameElement,width,height);\n\
   }\n\
}\n\
\n"

/*
~~~~~~~~~~~~~~~~~~~~
setFontSize(), setCommand(), setUtility() are called "remotely" via
xhr.onprogress() in doScreper().
*/

"function setFontSize(size) {\n\
   document.body.style.fontSize = size;\n\
}\n\
\n\
function setCommand(string) {\n\
   document.getElementById('screperCommand').innerHTML = string;\n\
}\n\
\n\
function setUtility(string) {\n\
   document.getElementById('screperUtility').innerHTML = string;\n\
}\n\
\n\
function pauseClick() {\n\
   var clk = document.getElementById('pauseButton');\n\
   if (clk)\n\
      clk.addEventListener(\"click\",pauseResume);\n\
   else\n\
      setTimeout(pauseClick,100);\n\
}\n\
setTimeout(pauseClick,100);\n\
</script>\n";

/*
~~~~~~~~~~~~~~~~~~~~
Iframe meta characteristics can only be managed via the parent page where
multiple terminals are displayed.
*/

static char  ResizeJavaScript [] =
"<script>\n\
var maxHeight;\n\
function resizeIframe(fobj,width,height) {\n\
   fobj.style.borderWidth = 0;\n\
   fobj.width = width;\n\
   if (maxHeight && height > maxHeight) {\n\
      console.log(height+'>'+maxHeight);\n\
      height = maxHeight;\n\
   }\n\
   fobj.height = height;\n\
};\n\
</script>\n";

/*
~~~~~~~~~~~~~~~~~~~~
Pause-all button on parent page used where multiple terminals displayed.
*/

static char  ButtonPauseAll [] =
"<script>\n\
var screperAllPaused = false;\n\
function pauseAll() {\n\
   return screperAllPaused;\n\
}\n\
function pauseAllResume() {\n\
   if (screperAllPaused)\n\
      document.getElementById('pauseAllButton').innerHTML = '"
BUTTON_PAUSEALL "';\n\
   else\n\
      document.getElementById('pauseAllButton').innerHTML = '"
BUTTON_UNPAUSEALL "';\n\
   screperAllPaused = !screperAllPaused;\n\
}\n\
function pauseAllClick() {\n\
   var clk = document.getElementById('pauseAllButton');\n\
   if (clk)\n\
      clk.addEventListener(\"click\",pauseAllResume);\n\
   else\n\
      setTimeout(pauseAllClick,100);\n\
}\n\
setTimeout(pauseAllClick,100);\n\
</script>\n\
<button id=\"pauseAllButton\" type=\"submit\" \
style=\"width:7em;max-width:7em;margin-top:1em;\">"
BUTTON_PAUSEALL "</button>\n";

/*******/
/* CSS */
/*******/

/* ensure monospace is explcitly specified!! */

static char PageCSS [] =
"\
<style type=\"text/css\">\n\
\
body { font-family:arial,verdana,helvetica,sans; font-size:11pt; \
background-color:white; color:black; margin:1em; }\n\
.screperCommand { display:inline-block; margin:0 0 0 1em; \
font-family:courier, lucida console, monaco, monospace; }\n\
.screperReport { background-color:yellow; color:black; }\n\
.screperScreen { font-family:courier, lucida console, monaco, monospace; \
font-size:1.0em; line-height:100%; \
white-space:pre; border-left: 1px white dotted; }\n\
.screperStatus { margin:0 0 0 1em; font-size:120%%; font-style:italic; }\n\
.screperScrolled { margin:0 0 0 1em; font-size:110%%; font-style:italic; }\n\
.screperUtility { margin:0 1em 0 1em; letter-spacing:0.07em; }\n\
#pauseButton { width:2.5em; max-width:2.5em; }\n\
\
._em1 { font-style:normal; font-weight:bold; }\n\
._em4 { font-style:normal; text-decoration:underline; }\n\
._em5 { font-style:normal; animation:blinker 1s step-start infinite; }\n\
._em7 { font-style:normal; background-color:black; color:white; }\n\
\
._attr { font-style:normal; background-color:aqua; }\n\
._chars { font-style:normal; background-color:lime; }\n\
._cmd { font-style:normal; background-color:khaki; }\n\
._kno { font-style:normal; background-color:orange; }\n\
._unk { font-style:normal; background-color:yellow; }\n\
._rxc { font-style:normal; background-color:aqua; }\n\
._data { font-style:normal; background-color:lightcyan; \
display:inline-block; white-space:normal; width:80em; max-width:80em; \
border-bottom:1px dashed black; }\n\
._print { font-family:monospace; font-style:normal; \
background-color:lightgray; display:inline-block; }\n\
._dump { font-style:normal; background-color:lightcyan; \
display:inline-block; border-bottom:1px dashed black; }\n\
\
</style>\n\
";

/*****************************************************************************/
/*
Allocate the structure and set some defaults.
*/

void* ScreperInit ()

{
   char  *cptr;
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = calloc (1, sizeof(SCREPER_STRUCT));
   if (!scrptr) exit (vaxc$errno);

   scrptr->PtdBits8 = TT$M_EIGHTBIT;
   scrptr->PtdDevice = TT$_VT100;
   scrptr->PtdPageLength = 24;
   scrptr->PtdPageWidth = 80;
   scrptr->UtilityLength = sprintf (scrptr->Utility, "-utility");
   scrptr->ScrOut = fdopen (dup (fileno (stdout)), "w");

   if (!(cptr = getenv ("WWW_CSP_NONCE")))
      cptr = getenv ("CSP_NONCE");
   if (cptr)
   {
      scrptr->CspNonce = calloc (1, strlen(cptr)+1);
      strcpy (scrptr->CspNonce, cptr);
   }

   return ((void*)scrptr);
}

/*****************************************************************************/
/*
Release resources.
*/

void* ScreperDone (void *vscrptr)

{
   SCREPER_STRUCT  *scrptr;

   scrptr = (SCREPER_STRUCT*)vscrptr;

   if (scrptr->ScreenBuffer) free (scrptr->ScreenBuffer);
   if (scrptr->JavaScriptPage) free (scrptr->JavaScriptPage);
   if (scrptr->JavaScriptPause) free (scrptr->JavaScriptPause);
   if (scrptr->JavaScriptResize) free (scrptr->JavaScriptResize);
   if (scrptr->CspHeader) free (scrptr->CspHeader);
   if (scrptr->CspNonce) free (scrptr->CspNonce);

   fflush (scrptr->ScrOut);
   fclose (scrptr->ScrOut);

   free (scrptr);

   return (NULL);
}

/*****************************************************************************/
/*
Parse the string of screper directives to set up the virtual terminal session. 
When the -dcl directive is encountered the rest of the string is considered and
the terminal session is created and the DCL executed.  Returns a pointer to a
string which should begin with a DCL status value (e.g. %X00000001).
*/

char* ScreperDo (void *vscrptr, char *this)

{
   int  length, status;
   char  *aptr, *cptr, *sptr, *zptr;
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   if (!strncmp (this, "-csp", 4))
      return (ScreperCSP(vscrptr));

   if (!strncmp (this, "-version", 5))
      return (SoftwareId);

   scrptr = (SCREPER_STRUCT*)vscrptr;
   if (!scrptr) return ("%X00000014 hurrump");

   if (!strncmp (this, "-css", 4))
      return (PageCSS);

   if (!strncmp (this, "-javascript", 4))
   {
      if (!scrptr->CspNonce) return (PageJavaScript);
      scrptr->JavaScriptPage = calloc (1, sizeof(PageJavaScript) + 64);
      sprintf (scrptr->JavaScriptPage, "<script nonce=\"%s\">%s",
               scrptr->CspNonce, PageJavaScript + 8);
      return (scrptr->JavaScriptPage);
   }

   if (!strncmp (this, "-pause", 4))
   {
      if (!scrptr->CspNonce) return (ButtonPauseAll);
      scrptr->JavaScriptPause = calloc (1, sizeof(ButtonPauseAll) + 64);
      sprintf (scrptr->JavaScriptPause, "<script nonce=\"%s\">%s",
               scrptr->CspNonce, ButtonPauseAll + 8);
      return (scrptr->JavaScriptPause);
   }

   if (!strncmp (this, "-resize", 4))
   {
      if (!scrptr->CspNonce) return (ResizeJavaScript);
      scrptr->JavaScriptResize = calloc (1, sizeof(ResizeJavaScript) + 64);
      sprintf (scrptr->JavaScriptResize, "<script nonce=\"%s\">%s",
               scrptr->CspNonce, ResizeJavaScript + 8);
      return (scrptr->JavaScriptResize);
   }

   if (!strncmp (this, "-screen", 4))
      return (ScreperScreen (scrptr));

   scrptr->NoProgressSecs = DEFAULT_NO_PROGRESS;

   aptr = strdup (this);
   while (*aptr)
   {
      while (isspace(*aptr)) aptr++;
      cptr = aptr;
      while (*aptr && *aptr != '=' && !isspace(*aptr)) aptr++;
      if (*aptr == '=') aptr++;

      if (!strncmp (cptr, "-7bit", 4))
      {
         scrptr->PtdBits8 = 0;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-8bit", 4))
      {
         scrptr->PtdBits8 = TT$M_EIGHTBIT;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-ctrlz", 6))
      {
         scrptr->InputBuffer[0] = 0x1a;
         scrptr->InputLength = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-dcl", 4))
      {
         zptr = (sptr = scrptr->DclBuffer) + sizeof(scrptr->DclBuffer)-1;
         while (*aptr && sptr < zptr) *sptr++ = *aptr++;
         *sptr = '\0';
         sptr = ScreperBegin (scrptr);
         return (sptr);
      }

      if (!strncmp (cptr, "-device", 4))
      {
         scrptr->PtdDevice = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-eot", 4))
      {
         scrptr->SendEOT = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-etx", 4))
      {
         scrptr->SendETX = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-exit", 4))
      {
         while (*cptr && *cptr != '=') cptr++;
         if (*cptr) cptr++;
         aptr = ConfigString (cptr, scrptr->ExitBuffer,
                                    sizeof(scrptr->ExitBuffer),
                                    &scrptr->RespondLength);
         continue;
      }

      if (!strncmp (cptr, "-font", 4))
      {
         scrptr->FontSize = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-input", 4))
      {
         while (*cptr && *cptr != '=') cptr++;
         if (*cptr) cptr++;
         aptr = ConfigString (cptr, scrptr->InputBuffer,
                                    sizeof(scrptr->InputBuffer),
                                    &scrptr->InputLength);
         continue;
      }

      if (!strncmp (cptr, "-inspect", 4))
      {
         scrptr->InspectStream = atoi (aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-noecho", 6))
      {
         scrptr->NoEcho = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-noeot", 6))
      {
         scrptr->NoEOT = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-noetx", 6))
      {
         scrptr->NoETX = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-noerror", 6))
      {
         scrptr->NoError = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-nofatal", 6))
      {
         scrptr->NoFatal = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-noprogress", 7))
      {
         if (isdigit(*aptr)) scrptr->NoProgressSecs = atoi (aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-nowarn", 6))
      {
         scrptr->NoWarning = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-page", 4))
      {
         if (*aptr == '+')
            scrptr->PtdPageLength += atoi(++aptr);
         else
            scrptr->PtdPageLength = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-repeat", 4))
      {
         /* cannot both repeat and wait */
         scrptr->WaitSecs = 0;
         scrptr->RepeatSecs = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-sentinal", 4))
      {
         while (*cptr && *cptr != '=') cptr++;
         if (*cptr) cptr++;
         aptr = ConfigString (cptr, scrptr->SnapshotSentinal,
                                    sizeof(scrptr->SnapshotSentinal),
                                    &scrptr->SnapshotSentinalLength);
         continue;
      }

      if (!strncmp (cptr, "-scroll", 4))
      {
         if (isdigit(*aptr))
            scrptr->ScrollIntoView = atoi(aptr);
         else
            scrptr->ScrollIntoView = 1;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-snapshot", 4))
      {
         scrptr->SnapshotTenths = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-tt0", 4))
      {
         scrptr->chbuf[0] = strtol(aptr,(char**)NULL,0);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }
      if (!strncmp (cptr, "-tt1", 4))
      {
         scrptr->chbuf[1] = strtol(aptr,(char**)NULL,0);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }
      if (!strncmp (cptr, "-tt2", 4))
      {
         scrptr->chbuf[2] = strtol(aptr,(char**)NULL,0);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-timestamp", 4))
      {
         while (*cptr && *cptr != '=' && !isspace(*cptr)) cptr++;
         if (*cptr == '=')
         {
            if (*cptr) cptr++;
            aptr = ConfigString (cptr, scrptr->TimeStamp,
                                       sizeof(scrptr->TimeStamp),
                                       &scrptr->TimeStampLength);
         }
         if (!scrptr->TimeStamp[0]) strcpy (scrptr->TimeStamp, "!20%D\n\n");
         continue;
      }

      if (!strncmp (cptr, "-utility", 4))
      {
         while (*cptr && *cptr != '=') cptr++;
         if (*cptr) cptr++;
         aptr = ConfigString (cptr, scrptr->Utility,
                                    sizeof(scrptr->Utility),
                                    &scrptr->UtilityLength);
         continue;
      }

      if (!strncmp (cptr, "-wait", 4))
      {
         /* cannot both repeat and wait */
         scrptr->RepeatSecs = 0;
         scrptr->WaitSecs = atoi(aptr);
         /* effectively wait forever */
         if (!scrptr->WaitSecs) scrptr->WaitSecs = 9999 * 24 * 60 * 60;
         /* when waiting we must be snapshotting */
         if (!scrptr->SnapshotTenths) scrptr->SnapshotTenths = 5;
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      if (!strncmp (cptr, "-width", 4))
      {
         scrptr->PtdPageWidth = atoi(aptr);
         while (*aptr && !isspace(*aptr)) aptr++;
         continue;
      }

      while (*aptr && !isspace(*aptr)) aptr++;
      *aptr = '\0';
      sptr = calloc (1, aptr - cptr + 32);
      sprintf (sptr, "%%X00000014 Unknown: %s", cptr);
      return (sptr);
   }

   return ("%X00000001");
}

/*****************************************************************************/
/*
Generate a Content-Security-Policy: HTTP header and return a pointer to it.
Based on the presence of a WASD CGI variable CSP_NONCE.  Can be called with
|scrptr| NULL.
*/

static char* ScreperCSP (void *vscrptr)

{
   char  *cptr, *sptr;
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = (SCREPER_STRUCT*)vscrptr;

   if (scrptr)
   {
      if (scrptr->CspHeader) return (scrptr->CspHeader);
      if (!scrptr->CspNonce)
      {
         if (!(cptr = getenv ("WWW_CSP_NONCE")))
            cptr = getenv ("CSP_NONCE");
         if (cptr)
         {
            scrptr->CspNonce = calloc (1, strlen(cptr)+1);
            strcpy (scrptr->CspNonce, cptr);
         }
      }
      cptr = scrptr->CspNonce;
   }
   else
   if (!(cptr = getenv ("WWW_CSP_NONCE")))
      cptr = getenv ("CSP_NONCE");

   if (!cptr) return ("");

   sptr = calloc (1, 128 + 32);
   sprintf (sptr, "Content-Security-Policy: " 
            "script-src 'nonce-%s' 'self' 'strict-dynamic'; "
            "frame-ancestors 'self'; form-action 'self';\r\n",
            cptr);  
   if (scrptr) scrptr->CspHeader = sptr;

   return (sptr);
}

/*****************************************************************************/
/*
Validate the terminal session charactersitics and execute the DCL.  Return a
string beginning with a VMS status (e.g. %X00000001).
*/

static char* ScreperBegin (SCREPER_STRUCT *scrptr)

{
   static char  sbuf [64];

   int  status;
   char  *cptr;

   /*********/
   /* begin */
   /*********/

   if (!(scrptr->PtdDevice >= TT$_VT100 && scrptr->PtdDevice <= TT$_VT132) &&
       !(scrptr->PtdDevice >= TT$_LA36 && scrptr->PtdDevice <= TT$_LA210))
      return ("%X00000014 device");

   if (scrptr->TimeStamp[0]) scrptr->PtdPageLength += 2;

   if (scrptr->PtdPageLength < 24 || scrptr->PtdPageLength > MAX_PAGE)
      return ("%X00000014 page length (24..255)");

   if (scrptr->PtdPageWidth < 80 || scrptr->PtdPageWidth > MAX_WIDTH)
      return ("%X00000014 page width (80, 132, ..255)");

   if (scrptr->PtdBits8 && scrptr->PtdBits8 != TT$M_EIGHTBIT)
      return ("%X00000014 data bits (7, 8)");

   if (scrptr->RepeatSecs < 0)
      scrptr->RepeatSecs = -scrptr->RepeatSecs;

   if (scrptr->SnapshotTenths)
   {
      if (scrptr->RepeatSecs)
         return ("%X00000014 cannot repeat snapshots");
      if (scrptr->SnapshotTenths && (scrptr->SnapshotTenths < 5 ||
                                    scrptr->SnapshotTenths > 600))
         return ("%X00000014 1/10 second (5..600)");
   }

   if (!scrptr->DclBuffer[0])
      return ("%X00000014 requires DCL command(s)");

   if (scrptr->NoProgressSecs) noProgTimer64 *= scrptr->NoProgressSecs;

   if (scrptr->SnapshotTenths) snapTimer64 *= scrptr->SnapshotTenths;

   if (!scrptr->InspectStream)
      if (cptr = getenv ("SCREPER_INSPECT"))
         scrptr->InspectStream = atol (cptr);

   scrptr->AnsiMode = 1;

   status = PtdSpawn (scrptr);

   if (scrptr->InspectStream)
      fprintf (scrptr->ScrOut, "PtdSpawn() %%X%08.08X\n", status);

   sprintf (sbuf, "%%X%08.08X", status);

   return (sbuf);
}

/*****************************************************************************/
/*
Create a pseudo-terminal driver terminal session, spawn a process attached to
that session, and write CLI commands to that process.
*/

static int PtdSpawn (SCREPER_STRUCT *scrptr)

{
   static ulong  DevNamItem = DVI$_DEVNAM;
   static ulong  JpiMasterPidItem = JPI$_MASTER_PID;

   /* nowait nolognam noclisym nokeypad nocontrol */
   static unsigned long  flags = 0x6f;

   $DESCRIPTOR (PromptDsc, CliPrompt);
   $DESCRIPTOR (DevNameDsc, scrptr->PtdDevName);
   $DESCRIPTOR (PrcNamDsc, scrptr->PrcNam);

   int  status;
   ulong  btime [2];
   ushort  slen;
   ulong  JpiMasterPidPid;
   char  *cptr, *sptr, *zptr;

   /*********/
   /* begin */
   /*********/

   if (scrptr->InspectStream) fprintf (scrptr->ScrOut, "PtdSpawn()\n");

   sys$gettim (&btime);
   SentLong = '!$$!';
   sprintf (SentEOT, "!$$!EOT%08.08x", btime[0]);
   sprintf (SentETX, "!$$!ETX%08.08x", btime[0]);
   sprintf (SentSTX, "!$$!STX%08.08x", btime[0]);
   PromptLong = '$!!$';
   if (scrptr->NoEcho)
   {
      /* make the prompt a recognisable sentinal */
      CliPromptLength = sprintf (CliPrompt, "$!!$%08.08x___", btime[0]);
      PromptDsc.dsc$w_length = CliPromptLength;
   }
   else
      PromptDsc.dsc$w_length = 0;

   status = lib$getjpi (&JpiMasterPidItem, 0, 0, &JpiMasterPidPid, 0, 0);
   if (!(status & 1)) return (status);

   status = lib$get_ef (&scrptr->EfnRead);
   if (!(status & 1)) return (status);

   /* if not trying to REstart the subprocess */
   if (!scrptr->inadr[0])
   {
      status = sys$expreg (PTD_BUFFER_PAGES, &scrptr->inadr, 0, 0);
      if (!(status & 1)) return (status);

      scrptr->PtdReadBuffer = (char*)scrptr->inadr[0];
      scrptr->PtdWriteBuffer = (char*)scrptr->inadr[0] + PTD_READ_SIZE;

      /* set the terminal characteristics */
      if (!scrptr->chbuf[0])
         scrptr->chbuf[0] = (scrptr->PtdPageWidth << 16) |
                            (scrptr->PtdDevice << 8) | DC$_TERM;
      if (!scrptr->chbuf[1])
         scrptr->chbuf[1] = (scrptr->PtdPageLength << 24) |
                            scrptr->PtdBits8 | TT$M_SCOPE | TT$M_WRAP |
                            TT$M_MECHTAB | TT$M_LOWER | TT$M_TTSYNC;
      if (!scrptr->chbuf[2])
         scrptr->chbuf[2] = TT2$M_EDIT | TT2$M_HANGUP | TT2$M_ANSICRT |
                            TT2$M_AVO | TT2$M_DECCRT | TT2$M_DECCRT2;
   }

   memset ((char*)scrptr->inadr[0], 0,
           (char*)scrptr->inadr[1] - (char*)scrptr->inadr[0]);
   scrptr->PtdReadStatus = scrptr->LibSpawnPid =
      scrptr->LibSpawnStatus = scrptr->PtdWriteStatus =
      scrptr->ScrolledCount = scrptr->SentDetected = 0;

   status = ptd$create (&scrptr->PtdChan, 0,
                        scrptr->chbuf, sizeof(scrptr->chbuf),
                        0, 0, 0, &scrptr->inadr);
   if (!(status & 1)) return (status);

   status = lib$getdvi (&DevNamItem, &scrptr->PtdChan, 0, 0,
                        &DevNameDsc, &slen);
   scrptr->PtdDevName[DevNameDsc.dsc$w_length = slen] = '\0';
   if (!(status & 1)) return (status);

   scrptr->EotScrPtr = (int64)scrptr;
   scrptr->SynScrPtr = (int64)scrptr;
   scrptr->SnapScrPtr = (int64)scrptr;
   scrptr->TmoScrPtr = (int64)scrptr;

   sprintf (scrptr->PrcNam, "screper_%4.4X", JpiMasterPidPid & 0xffff);
   PrcNamDsc.dsc$a_pointer = scrptr->PrcNam;
   PrcNamDsc.dsc$w_length = strlen(scrptr->PrcNam);

   status = lib$spawn (0, &DevNameDsc, &DevNameDsc, &flags, &PrcNamDsc,
                       &scrptr->LibSpawnPid, &scrptr->LibSpawnStatus, 0,
                       &PtdSpawnAst, scrptr, &PromptDsc, 0, 0);
   if (!(status & 1)) return (status);

   for (int cnt = 10; cnt; cnt--)
   {
      sleep (1);
      if (scrptr->LibSpawnPid) break;
   }

   for (;;)
   {
      status = PtdWrite (scrptr);
      if (!(status && 1)) break;

      PtdRead (scrptr);

      /* wait for the output to finish */
      sys$hiber();

      /* if an error ETX then break */
      if (!((status = scrptr->SentDetected) & 1)) break;

      if (scrptr->WaitSecs) sleep (scrptr->WaitSecs);
      if (!scrptr->RepeatSecs) break;
      /* repeat every so many seconds */
      sleep (scrptr->RepeatSecs);
   }

   if (status & 1 && scrptr->LibSpawnStatus) status = scrptr->LibSpawnStatus;

   fprintf (scrptr->ScrOut, "<!-- screper:%d %%X%08.08X -->",
            __LINE__, status);
   fflush (scrptr->ScrOut);

   return (status);
}

/*****************************************************************************/
/*
Subprocess self-destruct.
*/

static void PtdPoof (SCREPER_STRUCT *scrptr, int status)

{
   ulong  pid;

   /*********/
   /* begin */
   /*********/

   if (scrptr->InspectStream)
   {
      fprintf (stdout, "PtdPoof() %%X%08.08X\n", status);
      fflush (stdout);
   }

   if (!scrptr->SentDetected) scrptr->SentDetected = status;
   if (scrptr->PtdChan) ptd$delete (scrptr->PtdChan);
   scrptr->PtdChan = 0;
   if (!(pid = scrptr->LibSpawnPid)) return;
   scrptr->LibSpawnPid = 0;
   sys$forcex (&pid, 0, status);
}

/*****************************************************************************/
/*
Subpocess completion AST.
*/

static void PtdSpawnAst (SCREPER_STRUCT *scrptr)

{
   /*********/
   /* begin */
   /*********/

   if (scrptr->InspectStream)
   {
      fprintf (stdout, "PtdSpawnAst() %%X%08.08X\n", scrptr->LibSpawnStatus);
      fflush (stdout);
   }

   if (!scrptr->SentDetected) scrptr->SentDetected = SS$_ABORT;
   if (!scrptr->LibSpawnStatus) scrptr->LibSpawnStatus = SS$_ABORT;
   if (scrptr->PtdChan) ptd$delete (scrptr->PtdChan);
   scrptr->LibSpawnPid = 0;
   sys$wake (0, 0);
}

/*****************************************************************************/
/*
Expects a string containing newline separated, multiple DCL commands, and
writes them successively to the subprocess' SYS$INPUT.  Any preceding the final
command are considered "setup" commands and not scraped.   Uses two sentinals
to delineate the start (STX) and end (ETX) of command output.  These are
detected by PtdRead().  Immediately before the final DCL command (i.e. not '\n'
terminated) the STX terminal is written as a commented "command", is echoed and
detectible by PtdRead().  When detected, the next read will be from the final
command and therefore valid data for screper to begin parsing.  Immediately
after the final command the ETX sentinal is similarly written as a commented
"command" to disable screen scraping.
*/

static int PtdWrite (SCREPER_STRUCT *scrptr)

{
   int  bcnt, status;
   char  *aptr, *bptr, *cptr, *sptr, *zptr;
   char  dclbuf [512];

   /*********/
   /* begin */
   /*********/

   /* begin the one minute <!-- SYN --> outputs */
   sys$setimr (0, &synTimer64, PtdScreperSyn, &scrptr->SynScrPtr, 0);

   ScreenReset (scrptr);

   /* look ahead DCL command stream */
   if (!(cptr = scrptr->RepeatCmdPtr))
   {
      cptr = scrptr->DclBuffer;
      while (*cptr)
      {
         while (*cptr) cptr++;
         while (cptr > scrptr->DclBuffer && *(cptr-1) == '\n') cptr--;
         while (cptr > scrptr->DclBuffer && *(cptr-1) != '\n') cptr--;
         scrptr->RepeatCmdPtr = cptr;
         /* excise the trailing newline */
         while (*cptr && (*cptr != '\n' || *cptr != '\n')) cptr++;
         *cptr = '\0';
      }
      cptr = scrptr->DclBuffer;
   }

   if (scrptr->FontSize)
      fprintf (scrptr->ScrOut, "<!-- $setFontSize(%dpt) -->\n",
                               scrptr->FontSize);

   if (scrptr->ScrollIntoView)
      fprintf (scrptr->ScrOut, "<!-- $setScrollIntoView(%d) -->\n",
                               scrptr->ScrollIntoView);

   if (scrptr->Utility[0])
      fprintf (scrptr->ScrOut, "<!-- $setUtility('%s') -->\n",
                               ScreperHtmlEncode(scrptr->Utility));

   fprintf (scrptr->ScrOut, "<!-- $setCommand('%s') -->\n",
                            ScreperHtmlEncode(scrptr->RepeatCmdPtr));

   zptr = (sptr = dclbuf) + sizeof(dclbuf)-1;

   /* remember, this is the DCL command stream */
   while (*cptr)
   {
      /* excise any leading carriage-control */
      while (*cptr == '\r' || *cptr == '\n') cptr++;
      if (!*cptr) break;

      for (bptr = cptr; *cptr && *cptr != '\r' && *cptr != '\n'; cptr++);
      while (*cptr == '\r' || *cptr == '\n') cptr++;
      if (!*cptr)
      {
         /* final command, start-of-text */
         for (aptr = SentSTX; *aptr && sptr < zptr; *sptr++ = *aptr++);
         if (sptr < zptr) *sptr++ = '\r';
      }
      cptr = bptr;

      while (*cptr && *cptr != '\r' && *cptr != '\n' && sptr < zptr)
         *sptr++ = *cptr++;
      if (sptr < zptr) *sptr++ = '\r';
      *sptr = '\0';
   }

   /* any -input or -ctrlz */
   for (cptr = scrptr->InputBuffer; *cptr && sptr < zptr; cptr++)
   if (sptr < zptr) *sptr++ = '\r';

   if (sptr >= zptr)
   {
      status = SS$_RESULTOVF;
      PtdPoof (scrptr, status);
      return (status);
   }

   if (scrptr->SendEOT && !scrptr->NoEOT)
   {
      /* subprocess is not restarted */
      for (cptr = SentEOT; *cptr && sptr < zptr; *sptr++ = *cptr++);
      if (sptr < zptr) *sptr++ = '\r';
      scrptr->ScrolledCount = 0;
   }
   else
   if (scrptr->SendETX && !scrptr->NoETX)
   {
      /* subprocess IS restarted */
      for (cptr = SentETX; *cptr && sptr < zptr; *sptr++ = *cptr++);
      if (sptr < zptr) *sptr++ = '\r';
   }
   else
   if (!scrptr->NoEOT && !scrptr->NoETX)
   {
      /* subprocess IS restarted */
      for (cptr = SentETX; *cptr && sptr < zptr; *sptr++ = *cptr++);
      if (sptr < zptr) *sptr++ = '\r';
   }
   *sptr = '\0';

   /* per repeated count */
   scrptr->ScrolledCount = 0;

   if (scrptr->InspectStream)
      fprintf (scrptr->ScrOut, "<em class=\"_cmd\">%s</em>\n", dclbuf);

   /* synchronous write command by command (avoids data overruns) */
   cptr = dclbuf;
   while (*cptr)
   {
      zptr = scrptr->PtdWriteBuffer + PTD_WRITE_SIZE;
      sptr = bptr = scrptr->PtdWriteBuffer + sizeof(ulong);
      while (*cptr && *cptr != '\r') *sptr++ = *cptr++;
      if (*cptr) *sptr++ = *cptr++;
      *sptr = '\0';
      bcnt = sptr - bptr;
      status = ptd$write (scrptr->PtdChan, 0, 0,
                          scrptr->PtdWriteBuffer, bcnt, 0, 0);
      if (!(status && 1)) break;
   }

   if (scrptr->InspectStream)
   {
      fprintf (scrptr->ScrOut, "%%X%08.08X %%X%08.08X %d\n",
               status, *(USHORTPTR)bptr, *(USHORTPTR)(bptr+2));
      fflush (scrptr->ScrOut);
   }

   if (!(status & 1)) PtdPoof (scrptr, status);

   fflush (scrptr->ScrOut);

   return (status);
}

/*****************************************************************************/
/*
Synchronous write direct to the PTD returing a VMS status value.
Record should be terminated with a carriage-return.
*/

static int PtdDollarWrite (ushort chan, char* bptr, int bcnt)

{
   int  status;

   /*********/
   /* begin */
   /*********/

   if (!bptr || !bcnt) return (SS$_BUGCHECK);
   status = ptd$write (chan, 0, 0, bptr, bcnt, 0, 0);
   return (status);
}

/*****************************************************************************/
/*
Read subprocess SYS$OUTPUT records.
*/

static void PtdRead (SCREPER_STRUCT *scrptr)

{
   int  bcnt, ch, status;
   char  *bptr, *cptr, *czptr, *sptr, *zptr;
   char  buf [PTD_READ_SIZE];

   /*********/
   /* begin */
   /*********/

   /* while just makes for a (semi-)structured break on -noecho */
   if (scrptr->PtdReadAst)
   {
      scrptr->PtdReadAst = 0;

      bptr = scrptr->PtdReadBuffer;

      scrptr->PtdReadStatus = *(USHORTPTR)bptr;
      if (!(scrptr->PtdReadStatus & 1))
         PtdPoof (scrptr, scrptr->PtdReadStatus);

      bptr += sizeof(ushort);
      bcnt = *(USHORTPTR)bptr;
      bptr += sizeof(ushort);
      /* ensure the read looks nul-terminated */
      *(USHORTPTR)(bptr + bcnt) = 0;

      if (scrptr->InspectStream >= 4)
      {
         fprintf (scrptr->ScrOut, "PtdRead(%d)\n", bcnt);
         ScreperPrint (scrptr, bptr, bcnt);
         ScreperData (scrptr, bptr, bcnt);
      }

      if (!scrptr->StxDetected)
      {
         /********************************/
         /* detect screen start sentinal */
         /********************************/

         czptr = (cptr = bptr) + bcnt;
         while (*(ULONGPTR)cptr != SentLong && cptr < czptr) cptr++;
         if (cptr < czptr)
         {
            if (!memcmp (cptr, SentSTX, sizeof(SentSTX)-1))
            {
               if (scrptr->InspectStream) fprintf (scrptr->ScrOut, "STX\n");
               scrptr->StxDetected++;
               fprintf (scrptr->ScrOut, "<!-- STX -->");
               fflush (scrptr->ScrOut);
            }
         }
      }
      else
      {
         /******************************/
         /* output after STX detection */
         /******************************/

         scrptr->StxDetected++;
         /* look for any take-snapshot sentinal string */
         if (scrptr->SnapshotSentinalLength)
            if (ScreenSentinal (scrptr, bptr, bcnt))
               ScreenScrape (scrptr, NULL, 0);
      }

      if (scrptr->StxDetected > 1)
      {
         /*****************************/
         /* ETX has not been detected */
         /*****************************/

         if (bcnt < 48)
         {
            /* detect the end of output sentinal */
            czptr = (cptr = bptr) + bcnt;
            while (*(ULONGPTR)cptr != SentLong && cptr < czptr) cptr++;
            if (cptr < czptr)
            {
               if (!memcmp (cptr, SentEOT, sizeof(SentEOT)-1))
               {
                  if (scrptr->InspectStream) fprintf (scrptr->ScrOut, "EOT\n");
                  if (!scrptr->SentDetected) scrptr->SentDetected = SS$_SHUT;
                  bcnt = 0;
               }
               else
               if (!memcmp (cptr, SentETX, sizeof(SentETX)-1))
               {
                  if (scrptr->InspectStream) fprintf (scrptr->ScrOut, "ETX\n");
                  if (!scrptr->SentDetected) scrptr->SentDetected = SS$_NORMAL;
                  bcnt = 0;
               }
            }
         }

         if (!scrptr->SentDetected)
         {
            /***************************/
            /* parse each content line */
            /***************************/

            czptr = (cptr = bptr) + bcnt;
            while (cptr < czptr)
            {
               zptr = (sptr = buf) + sizeof(buf)-1;
               while (*cptr < 32 && cptr < czptr) cptr++;
               while (cptr < czptr &&
                      (*(USHORTPTR)cptr == '\x0d\x0a' ||
                       *(USHORTPTR)cptr == '\x0a\x0d')) cptr += 2;
               while (cptr < czptr &&
                      *(USHORTPTR)cptr != '\x0d\x0a' &&
                      *(USHORTPTR)cptr != '\x0a\x0d')
               {
                  if (sptr < zptr)
                     *sptr++ = *cptr++;
                  else
                     cptr++;
               }
               *sptr = '\0';

               if (*buf == '%')
               {
                  /********************************/
                  /* potential VMS status message */
                  /********************************/

                  /* e.g. "%DIRECT-E-OPENIN," */
                  ch = 0;
                  for (sptr = buf+1; *sptr && isalnum(*sptr); sptr++);
                  if (*sptr == '-') sptr++;
                  if (*sptr) ch = *sptr++;
                  if (ch == 'W' || ch == 'E' || ch == 'F')
                  {
                     if (ch == 'F' && scrptr->NoFatal) ch = 0;
                     if (ch == 'E' && scrptr->NoError) ch = 0;
                     if (ch == 'W' && scrptr->NoWarning) ch = 0;
                     if (ch && *sptr == '-')
                     {
                        sptr++;
                        while (*sptr && isalnum(*sptr)) sptr++;
                        if (*sptr != ',') ch = 0;
                     }
                     else
                        ch = 0;
                  }
                  else
                     ch = 0;
                  if (ch)
                  {
                     ScreenScrape (scrptr, bptr, bcnt);
                     scrptr->SentDetected = SS$_ENDOFTAPE;
                     fprintf (scrptr->ScrOut, "<!-- screper:%d %%X%08.08X -->",
                              __LINE__, scrptr->SentDetected);
                     fflush (scrptr->ScrOut);
                  }
               }

               if (!scrptr->SentDetected && scrptr->ExitBuffer[0])
               {
                  /************************/
                  /* compare to any -exit */
                  /************************/

                  if (!strcmp (buf, scrptr->ExitBuffer))
                  {
                     ScreenScrape (scrptr, bptr, bcnt);
                     scrptr->SentDetected = SS$_ENDOFTAPE;
                     fprintf (scrptr->ScrOut, "<!-- screper:%d %%X%08.08X -->",
                              __LINE__, scrptr->SentDetected);
                     fflush (scrptr->ScrOut);
                  }
               }
            }
         }

         if (CliPromptLength)
         {
            /* if this line matches the prompt then do not echo (scrape) it */
            czptr = (cptr = bptr) + bcnt;
            while (*(ULONGPTR)cptr != PromptLong && cptr < czptr) cptr++;
            if (cptr < czptr)
            {
               if (!memcmp (cptr, CliPrompt, CliPromptLength))
               {
                  if (*(cptr + CliPromptLength))
                  {
                     fprintf (scrptr->ScrOut, "<!-- -NOECHO -->");
                     fflush (scrptr->ScrOut);
                     goto NextRead;
                  }
                  /* an OPCOM has the prompt trailing the message */
                  bcnt -= CliPromptLength;
                  /* also remove preceding nul chars */
                  while (bcnt && !bptr[bcnt-1]) bcnt--;
               }
            }
         }

         if (scrptr->SentDetected)
         {
            if (scrptr->SentDetected == SS$_NORMAL ||
                scrptr->SentDetected == SS$_SHUT)
            {
               /* these are both success codes */
               ScreenOutput (scrptr);
               if (scrptr->SentDetected == SS$_NORMAL)
                  fprintf (scrptr->ScrOut,
                           "<!-- ETX -->\n<!-- screper:%d %%X%08.08X -->\n",
                           __LINE__, scrptr->SentDetected);
               else
                  fprintf (scrptr->ScrOut,
                           "<!-- EOT -->\n<!-- screper:%d %%X%08.08X -->\n",
                           __LINE__, scrptr->SentDetected);
               fflush (scrptr->ScrOut);
               /* cancel timers */
               sys$cantim (&scrptr->EotScrPtr, 0);
               sys$cantim (&scrptr->SynScrPtr, 0);
               sys$cantim (&scrptr->SnapScrPtr, 0);
               sys$cantim (&scrptr->TmoScrPtr, 0);
               /* wake the caller */
               sys$wake (0, 0);
               return;
            }

            /* error ETX -- any more to the error report? */
            if (bcnt)
               if (bptr[0] != '\n' || (bptr[1] != ' ' && bptr[1] != '-'))
                  bcnt = 0;
         }

         ScreenScrape (scrptr, bptr, bcnt);

         if (scrptr->NoProgressSecs)
         {
            /* more output -- reset the no-progress timer */
            sys$cantim (&scrptr->TmoScrPtr, 0);
            sys$setimr (0, &noProgTimer64, PtdNoProgress,
                        &scrptr->TmoScrPtr, 0);
         }
      }

      if (scrptr->SentDetected)
      {
         if (!(scrptr->SentDetected & 1))
         {
            /* error EOT -- still more trailing output -- reset timer */
            sys$cantim (&scrptr->EotScrPtr, 0);
            sys$setimr (0, &etxTimer64, PtdScreperEot, &scrptr->EotScrPtr, 0);
         }
      }

      /* EWD would be frowning */
      NextRead:
   }

   /* asynchronous read */
   scrptr->PtdReadAst = 1;
   status = ptd$read (scrptr->EfnRead, scrptr->PtdChan, PtdRead, scrptr,
                      scrptr->PtdReadBuffer, PTD_READ_SIZE-(sizeof(ulong)));
   if (!(status & 1)) PtdPoof (scrptr, status);
}

/*****************************************************************************/
/*
Timer AST after short duration expiry to see if any more (error) output.
*/

static void PtdScreperEot (int64 *EotScrPtr)

{
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = (SCREPER_STRUCT*)(*(int64*)EotScrPtr);

   ScreenOutput (scrptr);

   fprintf (scrptr->ScrOut, "<!-- EOT -->\n<!-- screper:%d %%X%08.08X -->\n",
            __LINE__, scrptr->SentDetected);
   fflush (scrptr->ScrOut);

   PtdPoof (scrptr, scrptr->SentDetected);
}

/*****************************************************************************/
/*
Timer AST to output a SYN sequence every minute to ensure the server sees some
output and doesn't no-progress time it out.  The scraped NUL character also
keeps the terminal screen current.
*/

static void PtdScreperSyn (int64 *SynScrPtr)

{
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = (SCREPER_STRUCT*)(*(int64*)SynScrPtr);

   fputs ("<!-- SYN -->", scrptr->ScrOut);
   fflush (scrptr->ScrOut);

   ScreenScrape (scrptr, "\0", 1);
   ScreenOutput (scrptr);

   sys$setimr (0, &synTimer64, PtdScreperSyn, &scrptr->SynScrPtr, 0);
}

/*****************************************************************************/
/*
Timer AST after no-progress seconds.
*/

static void PtdNoProgress (int64 *TmoScrPtr)

{
   static $DESCRIPTOR (FaoDsc,
"\r\n\r\n\x1b[7m !20%D No progress timeout after !AZ. ");

   short  slen;
   char  buf1 [64],
         buf2 [128];
   $DESCRIPTOR (Buf2Dsc, buf2);
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = (SCREPER_STRUCT*)(*(int64*)TmoScrPtr);

   if (scrptr->NoProgressSecs >= 172800)
      sprintf (buf1, "%d days", scrptr->NoProgressSecs / 86400);
   else
   if (scrptr->NoProgressSecs > 86400)
      sprintf (buf1, "%d day", scrptr->NoProgressSecs / 86400);
   else
   if (scrptr->NoProgressSecs >= 7200)
      sprintf (buf1, "%d hours", scrptr->NoProgressSecs/ 3600);
   else
   if (scrptr->NoProgressSecs > 3600)
      sprintf (buf1, "%d hour", scrptr->NoProgressSecs / 3600);
   else
   if (scrptr->NoProgressSecs >= 120)
      sprintf (buf1, "%d minutes", scrptr->NoProgressSecs / 60);
   else
   if (scrptr->NoProgressSecs > 60)
      sprintf (buf1, "%d minute", scrptr->NoProgressSecs / 60);
   else
      sprintf (buf1, "%d seconds", scrptr->NoProgressSecs);

   sys$fao (&FaoDsc, &slen, &Buf2Dsc, 0, buf1);

   ScreenScrape (scrptr, buf2, slen);
   ScreenOutput (scrptr);
   fprintf (scrptr->ScrOut, "<!-- EOT -->\n<!-- screper:%d %%X%08.08X -->\n",
            __LINE__, scrptr->SentDetected = SS$_TIMEOUT);
   fflush (scrptr->ScrOut);
   PtdPoof (scrptr, scrptr->SentDetected);
}

/*****************************************************************************/
/*
Process output from the pseudo-terminal session.

The virtual terminal has a virtual cursor positioned by the current values of
/row/ and /col/ variables.  Columns are numbered 0..width-1 and rows 0..page-1.

Each cursor position in the virtual screen is 32 bits deep.

   0              7 8             15 16            23 24            31
  |................|................|................|................|
  |   8 bit char   |    SGR bits    |    G0 alpha    |    G1 alpha    |

                                     (these two fields are extravagant)

Function returns true to continue scraping or false to conclude program.
*/

static void ScreenScrape (SCREPER_STRUCT *scrptr, char *record, int length)

{
#define MAX_PN 10

   int  ch, cnt, ccnt, col, inspect, nlcnt, page, pncnt,
        rcnt, row, size, tab, width;
   int  pn [MAX_PN];
   ulong  value;
   ulong  *screen;
   char  *cptr, *czptr, *sptr, *zptr;

   /*********/
   /* begin */
   /*********/

   if (length <= 0) return;

   if (!scrptr->ScreenBuffer)
   {
      /* initialise */
      scrptr->ScreenBufferSize = scrptr->PtdPageLength *
                                 scrptr->PtdPageWidth *
                                 sizeof(ulong);
      scrptr->ScreenBuffer = (ulong*)calloc (1, scrptr->ScreenBufferSize);
      if (!scrptr->ScreenBuffer) exit (vaxc$errno);
      scrptr->CharTableG0 = 'B' << 16;
      scrptr->CharTableG1 = '0' << 24;
      scrptr->ScreenRow = scrptr->ScreenCol = 0;
      scrptr->CurSave = -1;
      /* kick off the ticker */
      if (scrptr->SnapshotTenths) ScreenSnapshot (&scrptr->SnapScrPtr);
   }

   if (scrptr->InspectStream >= 4)
      ScreenDump (scrptr, "BEFORE", __LINE__);

   /* get local copies of structure data */
   inspect = scrptr->InspectStream;
   screen = scrptr->ScreenBuffer;
   page = scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;
   row = scrptr->ScreenRow;
   col = scrptr->ScreenCol;

   if (inspect)
   {
      fprintf (scrptr->ScrOut, "ScreenScrape(%d) %dx%d\n", length, width, page);
      ScreperData (scrptr, record, length);
   }

   czptr = (cptr = record) + length;

   /* let the ticker know data has been received */
   scrptr->SnapshotDataCount += length;

   /************/
   /* populate */
   /************/

   while (cptr < czptr)
   {
      if ((*cptr >= 32 && *cptr < 127) ||
          (*cptr >= 160 && *cptr <= 255))
      {
         /*************/
         /* printable */
         /*************/

         /* replace leading nuls with with spaces */
         for (ccnt = col-1; ccnt >= 0; ccnt--)
            if (!screen[(row*width)+ccnt])
               screen[(row*width)+ccnt] = ' ';

         zptr = cptr;
         while (cptr < czptr &&
                ((*cptr >= 32 && *cptr < 127) ||
                 (*cptr >= 160 && *cptr <= 255)))
         {
            value = *cptr++;
            if (scrptr->SgrBold) value |= SGR_BOLD;
            if (scrptr->SgrBlink) value |= SGR_BLINK;
            if (scrptr->SgrUnder) value |= SGR_UNDER;
            if (scrptr->SgrReverse) value |= SGR_REVER;
            if (scrptr->SgrG1) value |= SGR_G1;
            value |= scrptr->CharTableG0;
            value |= scrptr->CharTableG1;

            /* insert this character */
            screen[(row*width)+col] = value;
            if (col < width) col++;
         }
         if (inspect) ScreperDump (scrptr, zptr, cptr - zptr);
         continue;
      }

      if ((*(USHORTPTR)cptr == '\x1b[') ||  /* 7 bit CSI */
          (*cptr == '\x9b'))                /* 8 bit CSI */
      {
         /*******/
         /* CSI */
         /*******/

         if (scrptr->InspectStream >= 4)
            ScreenDump (scrptr, FI_LI);

         if (*(USHORTPTR)cptr == '\x1b[')
            cptr += 2;
         else
            cptr++;

         if (inspect) ScreperKnown (scrptr, "CSI+", cptr, czptr);

         pncnt = 0;
         pn[pncnt++] = atoi(cptr);
         while (isdigit(*cptr) && cptr < czptr) cptr++;
         while (*cptr == ';')
         {
            if (cptr >= czptr) break;
            cptr++;
            pn[pncnt++] = atoi(cptr);
            if (pncnt >= MAX_PN) break;
            while (isdigit(*cptr) && cptr < czptr) cptr++;
         }
         if (cptr >= czptr) break;
         ch = *cptr++;

         if (ch == 'm')
         {
            /*******/
            /* SGR */
            /*******/

            for (cnt = 0; cnt < pncnt; cnt++)
            {
               if (pn[cnt] == 0)
                  scrptr->SgrBlink = scrptr->SgrBold =
                     scrptr->SgrReverse = scrptr->SgrUnder = 0;
               else
               if (pn[cnt] == 1)
                  scrptr->SgrBold = 1;
               else
               if (pn[cnt] == 4)
                  scrptr->SgrUnder = 1;
               else
               if (pn[cnt] == 5)
                  scrptr->SgrBlink = 1;
               else
               if (pn[cnt] == 7)
                  scrptr->SgrReverse = 1;
               if (inspect) printf ("<em class=\"_attr\">SGR "
                                    "%dx%d %d</em>\n", row, col, pn[cnt]);
            }
            continue;
         }

         if (ch >= 'A' && ch <= 'G')
         {
            /********/
            /* move */
            /********/

            if (ch == 'A')
            {
               /* move cursor up */
               if (row - pn[0] >= 0) row -= pn[0];
            }
            else
            if (ch == 'B')
            {
               /* move cursor down */
               if (row + pn[0] < page) row += pn[0];
            }
            else
            if (ch == 'C')
            {
               /* move cursor right */
               if (col + pn[0] < width) col += pn[0];
            }
            else
            if (ch == 'D')
            {
               /* move cursor left */
               if (col - pn[0] >= 0) col -= pn[0];
            }
            else
            if (ch == 'E')
            {
               /* moves cursor to beginning of lines down */
               if (row + pn[0] < page)
               {
                  row += pn[0];
                  col = 0;
               }
            }
            else
            if (ch == 'F')
            {
               /* moves cursor to beginning of lines up */
               if (row + pn[0] >= 0)
               {
                  row += pn[0];
                  col = 0;
               }
            }
            else
            if (ch == 'G')
            {
               /* move cursor to col */
               if (pn[0] >= 0 && pn[0] < width) col = pn[0];
            }
            if (inspect) ScreenCursor (scrptr, "ROWxCOL %dx%d", row, col);
            continue;
         }

         if (ch == 'H' || ch == 'f')
         {
            /*********/
            /* go to */
            /*********/

            /* row and col */
            /* our emulation has cols 0..width-1 and rows 0..page-1 */
            if (pn[0]) pn[0]--;
            if (pn[1]) pn[1]--;
            if (pn[0] < page) row = pn[0]; else row = page-1;
            if (pn[1] < width) col = pn[1]; else col = width-1;
            if (inspect) ScreenCursor (scrptr, "ROWxCOL %dx%d", row, col);
            continue;
         }

         if (ch == 'J')
         {
            /*********/
            /* erase */
            /*********/

            if (pn[0] == 0)
            {
               /* clear from current to end of screen */
               for (ccnt = col; ccnt < width; ccnt++)
                  screen[(row*width)+ccnt] = 0;
               /* then to end of screen */
               for (rcnt = row+1; rcnt < page; rcnt++)
                  for (ccnt = 0; ccnt < width; ccnt++)
                     screen[(rcnt*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE EOL %dx%d", row, col);
               continue;
            }
            if (pn[0] == 1)
            {
               /* clear start of screen to current */
               for (rcnt = 0; rcnt <= row; rcnt++)
                  for (ccnt = 0; ccnt < width; ccnt++)
                     screen[(rcnt*width)+ccnt] = 0;
               /* then clear from start of row up until the current col */
               for (ccnt = 0; ccnt <= col; ccnt++)
                  screen[(row*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE SOS %dx%d", row, col);
               continue;
            }
            if (pn[0] == 2)
            {
               /* clear screen */
               for (rcnt = 0; rcnt < page; rcnt++)
                  for (ccnt = 0; ccnt < width; ccnt++)
                     screen[(rcnt*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE CLS %dx%d", row, col);
               continue;
            }
            continue;
         }

         if (ch == 'K')
         {
            /*********/
            /* clear */
            /*********/

            if (pn[0] == 0)
            {
               /* clear to end of line */
               for (ccnt = col; ccnt < width; ccnt++)
                  screen[(row*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE %dx%d EOL", row, col);
               continue;
            }
            if (pn[0] == 1)
            {
               /* clear from start of line to current */
               for (ccnt = 0; ccnt <= col; ccnt++)
                  screen[(row*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE %dx%d SOL", row, col);
               continue;
            }
            if (pn[0] == 2)
            {
               /* clear all lines */
               for (rcnt = 0; rcnt < page; rcnt++)
                  for (ccnt = 0; ccnt < width; ccnt++)
                     screen[(rcnt*width)+ccnt] = 0;
               if (inspect) ScreenCursor (scrptr, "ERASE %dx%d CLS", row, col);
               continue;
            }
            continue;
         }

         if (ch == 'c')
         {
            /****************/
            /* what are you */
            /****************/

            PtdDollarWrite (scrptr->PtdChan, "\x1b[?1;0c", 7);
            continue;
         }

         if (ch == 'n')
         {
            /*****************/
            /* status report */
            /*****************/

            if (pn[0] == 0 || pn[0] == 5)
               PtdDollarWrite (scrptr->PtdChan, "\x1b[0n", 4);
            else
            if (pn[0] == 6)
            {
               char  buf [32];
               int len = sprintf (buf, "%c[%d;%dR", '\x1b', row+1, col+1);
               PtdDollarWrite (scrptr->PtdChan, buf, len);
            }
            else
               PtdDollarWrite (scrptr->PtdChan, "\x1b[3n", 4);
            continue;
         }

         if (ch == 's' || ch == 'u')
         {
            /**********/
            /* cursor */
            /**********/

            if (ch == 's')
            {
               /* save cursor */
               if (scrptr->CurSave < CSAVE_MAX)
               {
                  scrptr->CurSave++;
                  scrptr->RowSave[scrptr->CurSave] = row;
                  scrptr->ColSave[scrptr->CurSave] = col;
               }
               continue;
            }
            if (ch == 'u')
            {
               /* restore cursor */
               if (scrptr->CurSave >= 0)
               {
                  row = scrptr->RowSave[scrptr->CurSave];
                  col = scrptr->ColSave[scrptr->CurSave];
                  scrptr->CurSave--;
               }
               continue;
            }
            /* drop through */
         }

         if (*(USHORTPTR)cptr == '20')
         {
            /***********************/
            /* line feed / newline */
            /***********************/

            cptr += 2;
            if (*cptr == 'h' || *cptr == 'l')
            {
               cptr++;
               ScreenNextLine (scrptr, &row, &col);
               continue;
            }
         }

         if (ch == 'r')
         {
            /********************/
            /* scrolling region */
            /********************/

            /* ignore */
            if (inspect) ScreenCursor (scrptr, "SCROLL %dx%d",
                                       pn[0] ? pn[0] : pn[0]+1, pn[1]);
            continue;
         }

         if (*cptr == '?')
         {
            /************/
            /* VT modes */
            /************/

            /* ignore */
            if (inspect) ScreperKnown (scrptr, "VT", cptr+1, czptr);
            continue;
         }

         /* unknown CSI */
         if (inspect) ScreperUnknown (scrptr, "CSI?", cptr, czptr);

         continue;
      }

      if (*cptr == '\x1b' ||  /* 7 bit */
          *cptr == '\x9b')    /* 8 bit */
      {
         /*******/
         /* ESC */
         /*******/

         cptr++;
         ch = *cptr;
         cptr++;

         if (ch == '<')
         {
            /* enter ANSI mode */
            scrptr->AnsiMode = 1;
            continue;
         }

         if (ch == '\\')
         {
            /* 7 bit string terminator */
            continue;
         }

         if (ch == '=' || ch == '>')
         {
            /* keypad mode */
            continue;
         }

         if (ch == 'Z')
         {
            /* what are you */
            PtdDollarWrite (scrptr->PtdChan, "\x1b[?1;0c", 7);
            continue;
         }

         if (scrptr->AnsiMode)
         {
            /*************/
            /* ANSI mode */
            /*************/

            if (ch == 'D')
            {
               /* IND Index */
               ScreenIndex (scrptr, &col, &row);
               continue;
            }

            if (ch == 'E')
            {
               /* NEL Next Line (newline equiv) */
               ScreenNextLine (scrptr, &row, &col);
               continue;
            }

            if (ch == 'M')
            {
               /* TI Reverse Index */
               ScreenReverseIndex (scrptr, &row, &col);
               continue;
            }

            if (ch == '7')
            {
               /* save cursor */
               if (scrptr->CurSave < CSAVE_MAX)
               {
                  scrptr->CurSave++;
                  scrptr->RowSave[scrptr->CurSave] = row;
                  scrptr->ColSave[scrptr->CurSave] = col;
                  scrptr->SgrSave[scrptr->CurSave] =
                    screen[(rcnt*width)+ccnt] & SGR_MASK;
                  screen[(rcnt*width)+ccnt] &= ~SGR_MASK;
               }
               continue;
            }
            if (ch == '8')
            {
               /* restore cursor */
               if (scrptr->CurSave >= 0)
               {
                  row = scrptr->RowSave[scrptr->CurSave];
                  col = scrptr->ColSave[scrptr->CurSave];
                  screen[(rcnt*width)+ccnt] &= ~SGR_MASK;
                  screen[(rcnt*width)+ccnt] |=
                     scrptr->SgrSave[scrptr->CurSave];
                  scrptr->CurSave--;
               }
               continue;
            }
         }

         /*****************/
         /* non-printable */
         /*****************/

         if (ch == '\x9c')
         {
            /* 8 bit string terminator */
            continue;
         }

         if (ch == '6')
         {
            /* back index */
            continue;
         }

         if (ch == '9')
         {
            /* forward index */
            continue;
         }

         if (ch == 'D')
         {
            /* index */
            continue;
         }

         if (ch == 'c')
         {
            /* RIS reset */
            continue;
         }

         if (ch == 'm')
         {
            /* reverse Index */
            continue;
         }

         if (ch == '\\')
         {
            /* string terminator */
            continue;
         }

         if (ch == '(')
         {
            /* G0 character set */
            if (*cptr == 'A' || *cptr == 'B' ||
                *cptr == '0' || *cptr == '1' || *cptr == '2')
               scrptr->CharTableG0 = (uchar)*cptr << 16;
            cptr++;
            continue;
         }

         if (ch == ')')
         {
            /* G1 character set */
            if (*cptr == 'A' || *cptr == 'B' ||
                *cptr == '0' || *cptr == '1' || *cptr == '2')
               scrptr->CharTableG1 = (uchar)*cptr << 24;
            cptr++;
            continue;
         }

         /* unknown ESC - span intervening chars to the next escape */
         if (inspect) ScreperUnknown (scrptr, "ESC?", cptr, czptr);
         while (cptr < czptr)
         {
            if (*cptr == '\x1b' || *cptr == '\x9b') break;
            cptr++;
         }
         continue;
      }

      /***********/
      /* control */
      /***********/

      if (*cptr == '\r')
      {
         cptr++;
         col = 0;
         continue;
      }
      if (*cptr == '\b')
      {
         cptr++;
         if (col > 0) col--;
         continue;
      }
      if (*cptr == '\n' ||
          *cptr == '\f' ||
          *cptr == '\v')
      {
         cptr++;
         ScreenNextLine (scrptr, &row, &col);
         continue;
      }
      if (*cptr == '\x0e')
      {
         /* SO Invoke G1 character set */
         cptr++;
         if (inspect)
         {
            fprintf (scrptr->ScrOut, "<em class=\"_attr\">G1 %dx%d ", row, col);
            ScreperMore (scrptr, cptr, czptr - cptr > 10 ? 10 : czptr - cptr);
            fputs ("</em>\n", scrptr->ScrOut);
         }
         scrptr->SgrG1 = SGR_G1;
         continue;
      }
      if (*cptr == '\x0f')
      {
         /* SI Invoke G0 character set */
         cptr++;
         if (inspect)
         {
            fprintf (scrptr->ScrOut, "<em class=\"_attr\">G0 %dx%d ", row, col);
            ScreperMore (scrptr, cptr, czptr - cptr > 10 ? 10 : czptr - cptr);
            fputs ("</em>\n", scrptr->ScrOut);
         }
         scrptr->SgrG1 = 0;
         continue;
      }
      if (*cptr == '\v')
      {
         if (row+1 < page) row++;
         cptr++;
         continue;
      }
      if (*cptr == '\t')
      {
         for (tab = 8; tab > 0; tab--)
         {
//            screen[(row*width)+col] = ' ';
            if (col+1 < width) col++;
         }
         cptr++;
         continue;
      }

      /* ignore this control char */
      cptr++;

      if (row > page || col > width)
         ScreenReport (scrptr,
                       "BUGCHECK: %d 0x%02x terminal %dx%d screen %dx%d\n",
                       cptr - record, *cptr, width, page, col, row);
   }

   if (scrptr->InspectStream >= 4)
      ScreenDump (scrptr, "AFTER", __LINE__);

   /* return local copies to strcuture data */
   scrptr->ScreenRow = row;
   scrptr->ScreenCol = col;
}

/*****************************************************************************/
/*
Moves the cursor to the first position on the next line.  If the cursor is at
the bottom margin, the page scrolls up.
*/

static void ScreenNextLine (SCREPER_STRUCT *scrptr, int *rowptr, int *colptr)

{
   /*********/
   /* begin */
   /*********/

   ScreenIndex (scrptr, rowptr, colptr);
   *colptr = 0;
}

/*****************************************************************************/
/*
Moves the cursor down one line in the same column.  If the cursor is at the
bottom margin, the page scrolls up.
*/

static void ScreenIndex (SCREPER_STRUCT *scrptr, int *rowptr, int *colptr)

{
   int  ccnt, col, page, rcnt, row, width;
   ulong  *screen;

   /*********/
   /* begin */
   /*********/

   screen = scrptr->ScreenBuffer;
   page = scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;

   row = *rowptr;
   col = *colptr;

   if (row+1 < page)
      row++;
   else
   {
      /* move all lines up one then clear the bottom row */
      for (rcnt = 0; rcnt < page-1; rcnt++)
         for (ccnt = 0; ccnt < width; ccnt++)
            screen[(rcnt*width)+ccnt] = screen[((rcnt+1)*width)+ccnt]; 
      for (ccnt = 0; ccnt < width; ccnt++)
         screen[(row*width)+ccnt] = 0;
      scrptr->ScrolledCount++;
   }

   *rowptr = row;
   *colptr = col;
}

/*****************************************************************************/
/*
Moves the cursor up one line in the same column.  If the cursor is at the top
margin, the page scrolls down.
*/

static void ScreenReverseIndex (SCREPER_STRUCT *scrptr,
                                int *rowptr, int *colptr)

{
   int  ccnt, col, page, rcnt, row, width;
   ulong  *screen;

   /*********/
   /* begin */
   /*********/

   screen = scrptr->ScreenBuffer;
   page = scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;

   row = *rowptr;
   col = *colptr;

   if (row-1 >= 0)
      row--;
   else
   {
      /* move all lines down one then clear the top row */
      for (rcnt = 0; rcnt+1 < page; rcnt++)
         for (ccnt = 0; ccnt < width; ccnt++)
            screen[(rcnt*width)+ccnt] = screen[((rcnt+1)*width)+ccnt]; 
      for (ccnt = row = 0; ccnt < width; ccnt++)
         screen[(row*width)+ccnt] = 0;
   }

   *rowptr = row;
   *colptr = col;
}

/*****************************************************************************/
/*
Scanning from row 1, column 1, to row /n/, column /n/ output the HTML
equivalent of the virtual terminal.  Only output leading spaces if followed by
a non-space character.  Count empty lines and only output if followed by a
non-empty line (so absorbing trailing empty lines).  Each 64 bit
character/attributes is is turned into an HTML string using ScreenChar().
*/

static void ScreenOutput (SCREPER_STRUCT *scrptr)

{
   int  ccnt, col, inspect, nlcnt, page, rcnt, row, spacnt, width, valcnt;
   ulong  value;
   ulong  *screen;

   /*********/
   /* begin */
   /*********/

   /* if no more data to display since last time */
   if (!scrptr->SnapshotDataCount) return;
   scrptr->SnapshotDataCount = 0;

   /* get local copies of structure data */
   inspect = scrptr->InspectStream;
   screen = scrptr->ScreenBuffer;
   page = scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;
   row = scrptr->ScreenRow;
   col = scrptr->ScreenCol;

   if (inspect) fprintf (scrptr->ScrOut, "ScreenOutput %dx%d\n", width, page);

   if (inspect >= 4) ScreenDump (scrptr, "OUTPUT", __LINE__);

   if (scrptr->TimeStamp[0]) ScreenTimeStamp (scrptr);

   nlcnt = 0;
   for (rcnt = 0; rcnt < page; rcnt++)
   {
      spacnt = valcnt = 0;
      for (ccnt = 0; ccnt < width; ccnt++)
      {
         value = screen[(rcnt*width)+ccnt];
         /* count any leading space characters */
         if (((value & CHAR_MASK) == ' ') && !valcnt && spacnt >= 0)
         {
            spacnt++;
            value = 0;
         }
         if (value)
         {
            if (spacnt >= 0)
            {
               /* there have been leading spaces, go back and output them */
               valcnt = spacnt;
               ccnt -= spacnt + 1;
               spacnt = -1;
               continue;
            }
            if (nlcnt)
            {
               while (nlcnt--) fputs ("\n", scrptr->ScrOut);
               nlcnt = 0;
            }
            valcnt++;
            fputs (ScreenChar (scrptr, value), scrptr->ScrOut);
         }
      }
      if (valcnt)
         fputs ("\n", scrptr->ScrOut);
      else
         nlcnt++;
   }



   if (scrptr->ScrolledCount)
      fprintf (scrptr->ScrOut, "<!-- $setScrolledCount(%d) -->\n",
                               scrptr->ScrolledCount);

   fputs (ScreenChar (scrptr, SGR_RESET), scrptr->ScrOut);
   scrptr->SgrBlink = scrptr->SgrBold = scrptr->SgrGrone =
      scrptr->SgrReverse = scrptr->SgrG1 = scrptr->SgrUnder = 0;

   fflush (scrptr->ScrOut);
}

/*****************************************************************************/
/*
Return a pointer to a string with any SGR attributes and character or HTML
character entity.
*/

static char* ScreenChar (SCREPER_STRUCT *scrptr, ulong value)

{
   ulong  ch;
   char  *cptr, *sptr;

   /*********/
   /* begin */
   /*********/

   sptr = scrptr->SgrBuffer;
   *sptr = '\0';

   if (value & SGR_RESET)
   {
      if (scrptr->SgrBold) strcat (sptr, "</em>");
      if (scrptr->SgrBlink) strcat (sptr, "</em>");
      if (scrptr->SgrUnder) strcat (sptr, "</em>");
      if (scrptr->SgrReverse) strcat (sptr, "</em>");
      scrptr->SgrBlink = scrptr->SgrBold =
         scrptr->SgrReverse = scrptr->SgrUnder = 0;
      return (sptr);
   }

   if (value & SGR_BOLD)
   {
      if (!scrptr->SgrBold) strcat (sptr, "<em class=\"_em1\">");
      scrptr->SgrBold = 1;
   }
   else
   {
      if (scrptr->SgrBold) strcat (sptr, "</em>");
      scrptr->SgrBold = 0;
   }

   if (value & SGR_UNDER)
   {
      if (!scrptr->SgrUnder) strcat (sptr, "<em class=\"_em4\">");
      scrptr->SgrUnder = 1;
   }
   else
   {
      if (scrptr->SgrUnder) strcat (sptr, "</em>");
      scrptr->SgrUnder = 0;
   }

   if (value & SGR_BLINK)
   {
      if (!scrptr->SgrBlink) strcat (sptr, "<em class=\"_em5\">");
      scrptr->SgrBlink = 1;
   }
   else
   {
      if (scrptr->SgrBlink) strcat (sptr, "</em>");
      scrptr->SgrBlink = 0;
   }

   if (value & SGR_REVER)
   {
      if (!scrptr->SgrReverse) strcat (sptr, "<em class=\"_em7\">");
      scrptr->SgrReverse = 1;
   }
   else
   {
      if (scrptr->SgrReverse) strcat (sptr, "</em>");
      scrptr->SgrReverse = 0;
   }

   ch = value & CHAR_MASK;

   if (ch > 127)
      cptr = CharTable_128_255[(uchar)ch-128];
   else
   if (ch < 32)
//      cptr = CharTable_0_31[(uchar)ch];
      cptr = "&dtrif;";
   else
   if (ch < 95)
      cptr = CharTable_32_94[(uchar)ch-32];
   else
   if (value & SGR_G1)
      cptr = CharTable_SG_95_127[(uchar)ch-95];
   else
      cptr = CharTable_95_127[(uchar)ch-95];

   strcat (sptr, cptr);

   return (sptr);
}

/*****************************************************************************/
/*
Reset the screen content.
*/

static void ScreenReset (SCREPER_STRUCT *scrptr)

{
   int  ccnt, page, rcnt, width;
   ulong  *screen;

   /*********/
   /* begin */
   /*********/

   page = scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;

   if (screen = scrptr->ScreenBuffer)
      for (rcnt = 0; rcnt < page; rcnt++)
         for (ccnt = 0; ccnt < width; ccnt++)
            screen[(rcnt*width)+ccnt] = 0;

   scrptr->ScreenRow = scrptr->ScreenCol =
      scrptr->SentDetected = scrptr->StxDetected = 0;
}

/*****************************************************************************/
/*
Get a quoted string.  A character beginning ^ needs two hex digits following to
define the character.  For example, ^1a is a control-z, ^3e a hat, ^22 a
literal quotation character.  Return a pointer to the next character.
*/

static char* ConfigString (char *string, char *buf, int size, int *lenptr)

{
   char  ch, ch0;
   char  *cptr, *sptr, *zptr;

   /*********/
   /* begin */
   /*********/

   if (size <= 0 || !buf || !string)
   {
      if (lenptr) *lenptr = 0;
      return (string);
   }
   if (buf) *buf = '\0';
   if (*string == '\"')
   {
      ch0 = '\"';
      string++;
   }
   else
      ch0 = 0;

   zptr = (sptr = buf) + size-1;
   for (cptr = string; *cptr && sptr < zptr; cptr++)
   {
      if (ch0 == '\"' && *cptr == ch0) break;
      if (!ch0 && isspace(*cptr)) break;
      if (*cptr == '^')
      {
         cptr++;
         if (*cptr && *(cptr+1))
         {
            ch = *(cptr+2);
            *sptr++ = (uchar)strtol (cptr, NULL, 16);
            *(cptr+2) = ch;
            cptr++;
         }
         else
            if (*cptr) cptr++;
      }
      else
         *sptr++ = *cptr;
   }
   *sptr = '\0';
   if (lenptr) *lenptr = sptr - buf;
   /* just in case we ran out of storage */
   while (*cptr)
   {
      if (ch0 == '\"' && *cptr == ch0) break;
      if (!ch0 && isspace(*cptr)) break;
      cptr++;
   }
   if (*cptr && ch0 == '\"') cptr++;
   return (cptr);
}

/*****************************************************************************/
/*
Look for the client-specified (-sentinal=..) output sentinal in the record. 
Return true or false. 
*/

static int ScreenSentinal (SCREPER_STRUCT *scrptr, char* record, int length)

{
   char  *cptr, *czptr, *sptr;

   /*********/
   /* begin */
   /*********/

   czptr = (cptr = record) + length;
   sptr = scrptr->SnapshotSentinal;
   length = scrptr->SnapshotSentinalLength;
   while (cptr + scrptr->SnapshotSentinalLength < czptr)
   {
      if (*cptr == *sptr)
         if (!(memcmp (cptr, sptr, length)))
            return (1);
      cptr++;
   }
   if (cptr < czptr) return (1);
   return (0);
}

/*****************************************************************************/
/*
This function is called every 100mS (i.e. ten times a second).  If these
specific number of these ticks has expired (i.e. the specified number of 100mS)
then output the scraped screen.  If not just return.  Each time screen data
arrives the ticker is reset and must tick down to zero before being output as
HTML.
*/

static void ScreenSnapshot (int64 *SnapScrPtr)

{
   int  status;
   SCREPER_STRUCT  *scrptr;

   /*********/
   /* begin */
   /*********/

   scrptr = (SCREPER_STRUCT*)(*(int64*)SnapScrPtr);

   if (scrptr->SnapshotDataCount)
   {
      if (scrptr->InspectStream)
         fprintf (scrptr->ScrOut, "ScreenSnapshot() %d\n",
                  scrptr->SnapshotDataCount);
      /* output the page as HTML */
      ScreenOutput (scrptr);
      scrptr->SnapshotDataCount = 0;

      /* more output -- reset the no-progress timer */
      sys$cantim (&scrptr->TmoScrPtr, 0);
      sys$setimr (0, &noProgTimer64, PtdNoProgress, &scrptr->TmoScrPtr, 0);
   }

   status = sys$setimr (0, &snapTimer64, &ScreenSnapshot,
                        &scrptr->SnapScrPtr, 0);
   if (!(status & 1)) exit (status);
}

/*****************************************************************************/
/*
*/

static void ScreenTimeStamp (SCREPER_STRUCT *scrptr)

{
   int  status;
   short  slen;
   char  *cptr, *sptr;
   char  ch;
   char  tbuf [255];
   time_t  utime;
   struct tm  *tmptr;
   $DESCRIPTOR (faoDsc, "");
   $DESCRIPTOR (tbufDsc, tbuf);

   /*********/
   /* begin */
   /*********/

   cptr = scrptr->TimeStamp;

   for (sptr = cptr; *cptr && *cptr != '!' && *cptr != '%'; cptr++);
   fprintf (scrptr->ScrOut, "%*.*s", cptr-sptr, cptr-sptr, sptr);

   if (*cptr == '!')
   {
      /* VMS time format */
      faoDsc.dsc$a_pointer = sptr = cptr;
      while (*cptr && *cptr != '<') cptr++;
      faoDsc.dsc$w_length = cptr - sptr;
      status = sys$fao (&faoDsc, &slen, &tbufDsc, 0);
      tbuf[slen] = '\0';
   }
   else
   if (*cptr == '%')
   {
      /* strftime() time format */
      time (&utime);
      tmptr = localtime (&utime);
      for (sptr = cptr; *cptr && *cptr != '<'; cptr++);
      ch = *cptr;
      slen = strftime (tbuf, sizeof(tbuf), sptr, tmptr);
      if (!slen) strcpy (tbuf, "strftime() ERROR");
      *cptr = ch;
   }
   fprintf (scrptr->ScrOut, "%*.*s", slen, slen, tbuf);

   for (sptr = cptr; *cptr; cptr++);
   fprintf (scrptr->ScrOut, "%*.*s", cptr-sptr, cptr-sptr, sptr);
}

/*****************************************************************************/
/*
If the /fmt/ parameter is NULL output and then empty the report buffer.
If not NULL then append a formatted string to the report buffer.
*/

static void ScreenReport (SCREPER_STRUCT *scrptr, char *fmt, ...)

{
#define BUF_SIZE 1024

   static char  buf [BUF_SIZE+128];
   static char  *bptr = buf;

   int  argcnt;
   va_list  argptr;

   /*********/
   /* begin */
   /*********/

   if (!fmt)
   {
      if (!buf[0]) return;
      fprintf (scrptr->ScrOut,
               "<span class=\"screperReport\">\n%s</span>",
               buf);
      *(bptr = buf) = '\0';
      return;
   }
   if (bptr - buf > BUF_SIZE) return;

   va_count (argcnt);
   va_start (argptr, fmt);

   if (vsprintf (bptr, fmt, argptr) < 0)
      sprintf (bptr, "ERROR: %s\n", fmt);
   while (*bptr) bptr++;
}

/*****************************************************************************/
/*
Returns a pointer to the HTML, et.al. required by the parent browser app to
display the virtual screen.
*/

char* ScreperScreen ()

{
   static char screen [] = 
"<pre class=\"screperScreen\" id=\"screperScreen\"></pre>\n\
<span class=\"screperUtility\" id=\"screperUtility\"></span>\
<button id=\"pauseButton\" type=\"submit\">\
" BUTTON_PAUSE "</button>\n\
<span id=\"screperCommand\" class=\"screperCommand\"></span>\n\
<span id=\"screperScrolled\" class=\"screperScrolled\"></span>\n\
<span id=\"screperStatus\" class=\"screperStatus\"></span>\n";

   char  *sptr;

   /*********/
   /* begin */
   /*********/

   return (screen);
}

/*****************************************************************************/
/*
Return a pointer to an allocated string containing encoded HTML-forbidden
characters.  The string can be free()ed after use, as required.
*/

char* ScreperHtmlEncode (char *string)

{
   int  cnt = 0;
   char  *aptr, *cptr, *eptr, *sptr;

   /*********/
   /* begin */
   /*********/

   for (cptr = string; *cptr; cptr++)
      if (*cptr && (*cptr == '<' || *cptr == '>' || *cptr != '&' ||
                    *cptr == '\"' || *cptr != '\'')) cnt++;
   aptr = sptr = calloc (1, cptr - string + (cnt * 6));
   for (cptr = string; *cptr; cptr++)
   {
      if (*cptr != '<' && *cptr != '>' && *cptr != '&' &&
          *cptr != '\"' && *cptr != '\'')
         *sptr++ = *cptr;
      else
      {
         if (*cptr == '<')
            eptr = "&lt;";
         else
         if (*cptr == '>')
            eptr = "&gt;";
         else
         if (*cptr == '\"')
            eptr = "&quot;";
         else
         if (*cptr == '\'')
            eptr = "&apos;";
         else
            eptr = "&amp;";
         while (*eptr) *sptr++ = *eptr++;
      }
   }
   return (aptr);
}

/****************************************************************************/
/*
$FAO formatted print statement to OPCOM.  A fixed-size, internal buffer of 986
bytes maximum is used and the result output as an OPCOM message.  If the format
string begins with "S/" it is sent to SOFTWARE, otherwise CENTRAL.
*/

void ScreperOpcom
(
char *FormatString,
...
)
{
   static $DESCRIPTOR (FaoDsc, "");
   static $DESCRIPTOR (OpcomDsc, "");
   static $DESCRIPTOR (OpcomMsgDsc, "");

   int  status, argcnt, target;
   unsigned short  ShortLength;
   unsigned long  *vecptr;
   unsigned long  FaoVector [31+1];
   va_list  argptr;
   struct
   {
      unsigned long  TargetType;
      unsigned long  RequestId;
      char  MsgText [986+1];
   } OpcomMsg;

   /*********/
   /* begin */
   /*********/

   va_count (argcnt);

   if (argcnt > 31+1) exit (SS$_OVRMAXARG);

   vecptr = FaoVector;
   va_start (argptr, FormatString);
   for (argcnt -= 1; argcnt; argcnt--)
      *vecptr++ = va_arg (argptr, unsigned long);
   va_end (argptr);
   *vecptr = 0;

   if (*(USHORTPTR)FormatString == 'S/')
   {
      target = OPC$M_NM_SOFTWARE;
      FormatString += 2;
   }
   else
      target = OPC$M_NM_CENTRL;
   FaoDsc.dsc$a_pointer = FormatString;
   FaoDsc.dsc$w_length = strlen(FormatString);

   OpcomMsgDsc.dsc$a_pointer = (char*)&OpcomMsg.MsgText;
   OpcomMsgDsc.dsc$w_length = sizeof(OpcomMsg.MsgText)-1;

   status = sys$faol (&FaoDsc, &ShortLength, &OpcomMsgDsc, &FaoVector);
   if (!(status & 1)) exit (status);

   OpcomMsg.MsgText[ShortLength] = '\0';
   OpcomMsg.TargetType = OPC$_RQ_RQST + ((target & 0xffffff) << 8);
   OpcomMsg.RequestId = 0;

   OpcomDsc.dsc$a_pointer = (char*)&OpcomMsg;
   OpcomDsc.dsc$w_length = ShortLength + 8;

   status = sys$sndopr (&OpcomDsc, 0);
   if (!(status & 1)) exit (status);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreenDump (SCREPER_STRUCT *scrptr, char *fi, int li)

{
   int  ccnt, page, rcnt, width;
   ulong  value;
   ulong  *screen;

   /*********/
   /* begin */
   /*********/

   if (!scrptr->InspectStream) return;

   page =scrptr->PtdPageLength;
   width = scrptr->PtdPageWidth;
   screen = scrptr->ScreenBuffer;

   fflush (scrptr->ScrOut);
   fprintf (scrptr->ScrOut, "<em class=\"_dump\">%s:%d\n    ", fi, li);
   for (ccnt = 0; ccnt < width; ccnt++)
      fprintf (scrptr->ScrOut, "%02d         ",ccnt);
   fputs ("\n", scrptr->ScrOut);
   fflush (scrptr->ScrOut);

   for (rcnt = 0; rcnt < page; rcnt++)
   {
      fprintf (scrptr->ScrOut, "%02d  ",rcnt);
      for (ccnt = 0; ccnt < width; ccnt++)
      {
         value = screen[(rcnt*width)+ccnt];
         fprintf (scrptr->ScrOut, "%08.08x %s ",
                  value, ScreenChar (scrptr, value & ~SGR_MASK));
      }
      fputs ("\n", scrptr->ScrOut);
      fflush (scrptr->ScrOut);
   }
   fputs ("</em>\n", scrptr->ScrOut);
   fflush (scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreenCursor (SCREPER_STRUCT *scrptr, char *fmt, ...)

{
   int  argcnt;
   va_list  argptr;

   /*********/
   /* begin */
   /*********/

   va_count (argcnt);
   va_start (argptr, fmt);

   fprintf (scrptr->ScrOut, "<em class=\"_rxc\">");
   vfprintf (scrptr->ScrOut, fmt, argptr);
   fprintf (scrptr->ScrOut, "</em>\n");
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperData (SCREPER_STRUCT *scrptr, char *cptr, int length)

{
   char  ch;
   char  *czptr;

   fputs ("<em class=\"_data\">", scrptr->ScrOut);
   czptr = cptr + length;
   while (cptr < czptr)
   {
      if ((ch = *cptr & ~SGR_MASK) > 31)
         fprintf (scrptr->ScrOut, "%02.02x%c ", *(uchar*)cptr, *cptr);
      else
         fprintf (scrptr->ScrOut, "%02.02x&#%d; ", *(uchar*)cptr, 9216 + *cptr);
      if (*cptr == '\n') fputs ("\n", scrptr->ScrOut);
      cptr++;
   }
   fputs ("</em>\n", scrptr->ScrOut);
   fflush (scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperPrint (SCREPER_STRUCT *scrptr, char *cptr, int length)

{
   char  ch;
   char  *czptr;

   czptr = cptr + length;
   fputs ("<span class=\"_print\">", scrptr->ScrOut);
   while (cptr < czptr)
   {
      if ((ch = *cptr & ~SGR_MASK) > 31)
         fputc (ch, scrptr->ScrOut);
      else
         fprintf (scrptr->ScrOut, "&#%d;", 9216 + ch);
      cptr++;
   }
   fprintf (scrptr->ScrOut, "</span>\n");
   fflush (scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperDump (SCREPER_STRUCT *scrptr, char *cptr, int length)

{
   char  ch;
   char  *czptr;

   czptr = cptr + length;
   fputs ("<span class=\"_chars\">", scrptr->ScrOut);
   while (cptr < czptr)
   {
      if ((ch = *cptr & ~SGR_MASK) > 31)
         fputc (ch, scrptr->ScrOut);
      else
         fprintf (scrptr->ScrOut, "&#%d;", 9216 + ch);
      cptr++;
   }
   fprintf (scrptr->ScrOut, "</span> %d\n", length);
   fflush (scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperKnown (SCREPER_STRUCT *scrptr, char* what,
                          char *cptr, char *czptr)

{
   fprintf (scrptr->ScrOut, "<em class=\"_kno\">%s ", what);
   ScreperMore (scrptr, cptr, czptr - cptr > 10 ? 10 : czptr - cptr);
   fputs ("</em>\n", scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperUnknown (SCREPER_STRUCT *scrptr, char* what,
                            char *cptr, char *czptr)

{
   fprintf (scrptr->ScrOut, "<em class=\"_unk\">%s ", what);
   ScreperMore (scrptr, cptr, czptr - cptr > 10 ? 10 : czptr - cptr);
   fputs ("</em>\n", scrptr->ScrOut);
}

/*****************************************************************************/
/*
Development tool.
*/

static void ScreperMore (SCREPER_STRUCT *scrptr, char *aptr, int count)

{
   if (count <= 0) count = 10;
   while (count)
   {
      fprintf (scrptr->ScrOut, "%02.02x%c ",
               *(uchar*)aptr, *aptr > 31 && *aptr < 127 ? *aptr : '.');
      aptr++;
      count--;
   }
   fflush (scrptr->ScrOut);
}

/*****************************************************************************/