#!/usr/bin/env lua

--

-- public

-- netcat text://protocol client

--

-- # textprint() { public "$1" 2>/dev/null; }

-- # textsource() { public "$1" 2>/dev/null | tee; }

-- # textlog() { public "$1" 1>/dev/null ; }

--

local arg = arg

local assert = assert

local io = require( 'io' )

local ipairs = ipairs

local math = require( 'math' )

local os = require( 'os' )

local pcall = pcall

local print = print

local string = require( 'string' )

local table = require( 'table' )

local tonumber = tonumber

local tostring = tostring

_ENV = nil

local _url = nil

local _host = nil

local _port = nil

local _name = nil

local _extension = nil

local _size = 0

local _status = nil

local _address = nil

local function URL()

if not _url then

_url = assert( arg[ 1 ] )

if '-' == _url then

_url = assert( io.stdin:read() )

end

_url = _url:match( '^(%C+)' )

assert( 0 ~= _url:len() )

assert( 1024 >= _url:len() )

assert( not _url:find( '%s' ) )

assert( _url == _url:lower() )

assert( 'text://' == _url:sub( 1, 7 ) )

_host = assert( _url:match( '^text://([%w.-]+)' ) )

_port = tonumber( _url:match( ':([%d]+)/' ) )

_name, _extension = _url:match( '/([%w-]+)%.(%w+)$' )

if '/' == _url:sub( -1, -1 ) then _name = 'index' _extension = 'txt' end

assert( _name )

assert( 0 ~= _name:len() )

assert( 128 >= _name:len() )

assert( _extension )

assert( 0 ~= _extension:len() )

assert( 3 >= _extension:len() )

end

return _url, _host, _port, _name, _extension, _size, _status

end

local function PRINT( aHandle, ... )

assert( aHandle:write( ... ) )

assert( aHandle:write( '\n' ) )

end

local function PRINTERR( ... )

PRINT( io.stderr, ... )

end

local function PRINTOUT( ... )

PRINT( io.stdout, ... )

end

local _controls = { [ '\r' ] = '\\r', [ '\n' ] = '\\n' }

local function LOGCMD( aCommand )

PRINTERR( '# ', ( aCommand:gsub( '%c', _controls ) ) )

end

local function QUOTE( anArgument )

return ( "'%s'" ):format( tostring( anArgument or '' ):gsub( "'", "'\\''" ) )

end

local function CHECKWHICH( aProgram )

local aCommand =

( 'which %s 2>/dev/null' ):format

(

QUOTE( aProgram )

)

--LOGCMD( aCommand )

local aHandle = io.popen( aCommand )

local aPath = aHandle:read()

aHandle:close()

if aPath then

return QUOTE( aPath )

end

return false

end

local _which = {}

local function WHICH( aProgram )

if _which[ assert( aProgram ) ] == nil then _which[ aProgram ] = CHECKWHICH( aProgram ) end

return _which[ aProgram ]

end

local function LOCALE()

local aCommand =

( '%s charmap 2>/dev/null' ):format

(

assert( WHICH( 'locale' ) )

)

LOGCMD( aCommand )

local aHandle = io.popen( aCommand, 'r' )

local aCharmap = assert( aHandle:read() )

assert( aHandle:close() )

assert( aCharmap )

assert( 0 ~= aCharmap:len() )

assert( 16 >= aCharmap:len() )

aCharmap = aCharmap:upper()

return aCharmap

end

local function CHECKTTY()

local aCommand =

( '%s -t 1 2>/dev/null' ):format

(

assert( WHICH( 'test' ) )

)

LOGCMD( aCommand )

local ok, exit, signal = os.execute( aCommand )

return ( ok and exit == 'exit' ) and signal == 0 or false

end

local _istty = nil

local function ISTTY()

if _istty == nil then _istty = CHECKTTY() end

return _istty

end

local function LOG( aMark, aDescription )

if not ISTTY() then return end

assert( aMark )

assert( aDescription )

aDescription = tostring( aDescription )

assert( aDescription )

assert( 0 ~= aDescription:len() )

assert( 144 >= aDescription:len() )

assert( not aDescription:find( '%c' ) )

PRINTOUT( aMark, ' ', aDescription )

end

local function INFO( aDescription )

LOG( '\u{2139}', aDescription )

end

local function WARNING( aDescription )

LOG( '\u{26A0}', aDescription )

end

local function ERROR( aDescription )

LOG( '\u{2716}', aDescription )

end

local function LINE()

if not ISTTY() then return end

PRINTOUT( '\u{2702}', ( '\u{30FB}' ):rep( 10 ) )

end

local function CLEAR()

if not ISTTY() then return end

if not WHICH( 'clear' ) then return end

local aCommand =

( '%s 2>/dev/null' ):format

(

assert( WHICH( 'clear' ) )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

end

local function ADDRESS( aHost )

if not WHICH( 'dig' ) then return end

local aCommand =

( '%s +nocomments +nofail +ignore +short +retry=0 +notcp +time=1 +tries=1 $(%s %s) A 2>/dev/null' ):format

(

assert( WHICH( 'dig' ) ),

assert( WHICH( 'idn2' ) or WHICH( 'printf' ) ),

QUOTE( aHost )

)

LOGCMD( aCommand )

local aHandle = io.popen( aCommand, 'r' )

local anAddress = aHandle:read()

aHandle:close()

if anAddress and ';;' == anAddress:sub( 1, 2 ) then anAddress = nil end

return anAddress

end

local function LOCATION( anAddress )

if not anAddress then return end

if not ISTTY() then return end

if not WHICH( 'mmdbinspect' ) then return end

if not WHICH( 'gron' ) then return end

local aCommand =

( '%s -db %s -db %s -db %s %s 2>/dev/null | %s' ):format

(

assert( WHICH( 'mmdbinspect' ) ),

QUOTE( '/usr/local/var/GeoIP/GeoLite2-ASN.mmdb' ),

QUOTE( '/usr/local/var/GeoIP/GeoLite2-Country.mmdb' ),

QUOTE( '/usr/local/var/GeoIP/GeoLite2-City.mmdb' ),

QUOTE( anAddress ),

assert( WHICH( 'gron' ) )

)

LOGCMD( aCommand )

local aHandle = io.popen( aCommand, 'r' )

local anOrganization = nil

local aCity = nil

local aPostalCode = nil

local anArea = nil

local aCountry = nil

local aBuffer = {}

for aLine in aHandle:lines() do

anOrganization = anOrganization or aLine:match( 'autonomous_system_organization = "(.-)";$' )

aCity = aCity or aLine:match( 'city%.names%.en = "(.-)";$' )

aPostalCode = aPostalCode or aLine:match( 'postal.code = "(.-)";$' )

anArea = anArea or aLine:match( 'subdivisions%[0%]%.names%.en = "(.-)";$' )

aCountry = aCountry or aLine:match( 'country%.names%.en = "(.-)";$' )

end

aHandle:close()

if anArea and aPostalCode then anArea = ( '%s %s' ):format( anArea, aPostalCode ) end

if anOrganization then aBuffer[ #aBuffer + 1 ] = anOrganization:gsub( '%-ASN$', '' ) end

if aCity then aBuffer[ #aBuffer + 1 ] = aCity end

if anArea then aBuffer[ #aBuffer + 1 ] = anArea end

if aCountry then aBuffer[ #aBuffer + 1 ] = aCountry end

INFO( ( '\u{2105} %s' ):format( table.concat( aBuffer, ', ' ) ):upper() )

end

local function PING( aHost )

if not ISTTY() then return end

if not WHICH( 'ping' ) then return end

if not WHICH( 'tail' ) then return end

local aCommand =

( '%s -c1 -q %s 2>/dev/null | %s -1' ):format

(

assert( WHICH( 'ping' ) ),

QUOTE( aHost ),

assert( WHICH( 'tail' ) )

)

LOGCMD( aCommand )

local aHandle = io.popen( aCommand, 'r' )

local aLine = aHandle:read() or ''

aHandle:close()

local aLatency = math.floor( tonumber( aLine:match( ' = (%d+.%d+)/' ) ) or 0 )

local aDescription = ( '\u{29D7} %ims' ):format( aLatency )

if 0 ~= aLatency then INFO( aDescription ) end

end

local function TMPDIR()

local aCommand =

(

'%s -d -q 2>/dev/null'

):format

(

assert( WHICH( 'mktemp' ) )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

local aDirectory = assert( aHandle:read() )

assert( aHandle:close() )

return assert( aDirectory )

end

local _directory = nil

local _sequence = 0

local function TMPNAME( aName, anExtension )

_directory = assert( _directory or TMPDIR() )

_sequence = _sequence + 1

assert( 99 > _sequence )

return ( '%s/%02i.%s.%s' ):format( _directory, _sequence, aName, anExtension )

end

local function MKFIFO( aPath )

local aCommand = ( '%s %s 2>/dev/null' ):format

(

WHICH( 'mkfifo' ),

QUOTE( aPath )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

return aPath

end

local function CHUNK( aHandle )

return function() return aHandle:read( 4096 ) end

end

local function TCPCONNECTION( aMultiAddr )

if not aMultiAddr.text:find( '/tcp/%d+$' ) then return end

if not WHICH( 'nc' ) then return end

local aConnection =

( '%s %s %i' ):format

(

assert( WHICH( 'nc' ) ),

QUOTE( aMultiAddr.address ),

aMultiAddr.port

)

return aConnection

end

local function TLSCONNECTION( aMultiAddr )

if not aMultiAddr.text:find( '/tcp/%d+/tls$' ) then return end

if not WHICH( 'openssl' ) then return end

local aConnection =

( '%s s_client -quiet -connect %s' ):format

(

assert( WHICH( 'openssl' ) ),

QUOTE( ( '%s:%i' ):format( aMultiAddr.address, aMultiAddr.port ) )

)

return aConnection

end

local function NOISECONNECTION( aMultiAddr )

if not aMultiAddr.text:find( '/tcp/%d+/noise$' ) then return end

if not WHICH( 'noisecat' ) then return end

local aConnection =

( '%s -v -proto Noise_XX_25519_ChaChaPoly_BLAKE2b %s %i' ):format

(

assert( WHICH( 'noisecat' ) ),

QUOTE( aMultiAddr.address ),

aMultiAddr.port

)

return aConnection

end

local _connectors = { NOISECONNECTION, TLSCONNECTION, TCPCONNECTION }

local function CONNECTION( aMultiAddr )

for _, aConnector in ipairs( _connectors ) do

local aConnection = aConnector( aMultiAddr )

if aConnection then return aConnection end

end

end

local function MULTIADDRBUILD( aText )

if '/ip4/' ~= aText:sub( 1, 5 ) then return end

local anAddress = aText:match( '^/ip4/(.-)/' )

local aPort = tonumber( aText:match( '/tcp/(%d+)' ) )

local aPriority = 0

aText = aText:gsub( ';(%d+)$', function( aValue ) aPriority = tonumber( aValue ) return '' end )

return { address = anAddress, port = aPort, priority = aPriority, text = aText }

end

local function MULTIADDRLOOKUP( aHost )

if not WHICH( 'dig' ) then return end

local aCommand =

( '%s +nocomments +nofail +ignore +short +retry=0 +notcp +time=1 +tries=1 $(%s %s) TXT 2>/dev/null' ):format

(

assert( WHICH( 'dig' ) ),

assert( WHICH( 'idn2' ) or WHICH( 'printf' ) ),

QUOTE( ( '_text._tcp.%s' ):format( aHost ) )

)

LOGCMD( aCommand )

local aHandle = io.popen( aCommand, 'r' )

local aList = {}

for aLine in aHandle:lines() do

local aText = aLine:match( '^"(.+)"$' )

local aMultiAddr = MULTIADDRBUILD( aText )

if aMultiAddr then

aList[ #aList + 1 ] = aMultiAddr

aList[ -aMultiAddr.port ] = aMultiAddr

end

end

table.sort( aList, function( aValue, anotherValue ) return aValue.priority < anotherValue.priority end )

aHandle:close()

return aList

end

local function MULTIADDRDISCOVER( aHost, aPort )

local aList = MULTIADDRLOOKUP( aHost )

if 0 == #aList then return end

if aList[ -( aPort or 0 ) ] then table.insert( aList, 1, aList[ -( aPort or 0 ) ] ) elseif aPort then assert( false ) end

for _, aMultiAddr in ipairs( aList ) do

aMultiAddr.connection = CONNECTION( aMultiAddr )

if aMultiAddr.connection then return aMultiAddr end

end

end

local _ports =

{

[ 1961 ] = '/ip4/{ip4}/tcp/{port}',

[ 1965 ] = '/ip4/{ip4}/tcp/{port}/tls',

[ 1968 ] = '/ip4/{ip4}/tcp/{port}/noise'

}

local function MULTIADDRDEFAULT( aHost, aPort )

local anAddress = ADDRESS( aHost ) or aHost

local aPort = aPort or 1961

local aText = _ports[ aPort ]

local aMultiAddr = {}

if not aText then aText = _ports[ 1 ] end

aText = aText:gsub( '{ip4}', anAddress )

aText = aText:gsub( '{port}', aPort )

aMultiAddr.address = anAddress

aMultiAddr.port = aPort

aMultiAddr.text = aText

aMultiAddr.connection = CONNECTION( aMultiAddr )

return aMultiAddr

end

local function MULTIADDR( aHost, aPort )

local aMultiAddress = MULTIADDRDISCOVER( aHost, aPort ) or MULTIADDRDEFAULT( aHost, aPort )

_address = assert( aMultiAddress.address )

assert( aMultiAddress.text )

assert( aMultiAddress.connection )

return aMultiAddress

end

local function REQUEST()

local aURL, aHost, aPort = URL()

INFO( ( '/dns/%s' ):format( aHost ):upper() )

local aMultiAddr = MULTIADDR( aHost, aPort )

INFO( aMultiAddr.text:upper() )

LOCATION( aMultiAddr.address )

PING( aMultiAddr.address )

local aResultName = MKFIFO( TMPNAME( 'result', 'fifo' ) )

local aCommand =

( '%s 0.5 %s 1>%s 2>/dev/null' ):format

(

assert( WHICH( 'timeout' ) ),

aMultiAddr.connection,

QUOTE( aResultName )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'w' ) )

assert( aHandle:write( aURL, '\r\n' ) )

assert( aHandle:flush() )

local aResultHandle = assert( io.open( aResultName, 'r' ) )

local aName = TMPNAME( 'response', 'raw' )

local aFile = io.open( aName, 'wb' )

local aSize = 0

for aChunk in CHUNK( aResultHandle ) do

aSize = aSize + aChunk:len()

assert( aFile:write( aChunk ) )

assert( 1048576 > aSize )

end

assert( aFile:close() )

assert( aResultHandle:close() )

aHandle:close()

return aName

end

local BOLD = 1

local DIM = 2

local UNDERLINE = 4

local function ANSI( aCode, aValue )

local aPattern = string.char( 27 ) .. '[%dm'

assert( aCode == 1 or aCode == 2 or aCode == 4 )

assert( aValue )

return ( '%s%s%s' ):format( aPattern:format( aCode ), aValue, aPattern:format( 0 ) )

end

local function NOANSI( aValue )

return

(

assert( aValue )

:gsub( '\x1b%[%d+;%d+;%d+;%d+;%d+m', '' )

:gsub( '\x1b%[%d+;%d+;%d+;%d+m', '' )

:gsub( '\x1b%[%d+;%d+;%d+m', '' )

:gsub( '\x1b%[%d+;%d+m', '' )

:gsub( '\x1b%[%d+m', '' )

)

end

local function STATUS( aResponseName )

local aResponseFile = assert( io.open( aResponseName, 'r' ) )

local aLine = assert( aResponseFile:read():match( '^(%C+)' ) )

assert( 0 ~= aLine:len() )

assert( 1024 >= aLine:len() )

assert( aLine == NOANSI( aLine ) )

assert( aResponseFile:close() )

local aStatus = assert( tonumber( aLine:match( '^(%d+) ' ) ) )

local aName = TMPNAME( 'status', 'txt' )

local aFile = assert( io.open( aName, 'w' ) )

assert( aFile:write( aLine, '\n' ) )

assert( aFile:close() )

local aCommand =

( '%s --from-code=UTF-8 --to-code=UTF-8 < %s >/dev/null' ):format

(

assert( WHICH( 'iconv' ) ),

QUOTE( aName )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

return aName, aStatus

end

local DISPLAY20TEXTPLAIN = nil

local function COMMA( amount )

local formatted, k = amount

repeat

formatted, k = string.gsub( formatted, '^(-?%d+)(%d%d%d)' , '%1,%2' )

until k == 0

return formatted

end

local function PLURAL( aCount, aSingular, aPlural )

if 0 == aCount then return aSingular end

if 1 == aCount then return aSingular end

return aPlural or ( '%ss' ):format( aSingular )

end

local function DISPLAY20BINARY( aContentName, aType, aCharset )

if not ISTTY() then return false end

local aCommand =

( '%s < %s | %s -b -w64 2>/dev/null' ):format

(

assert( WHICH( 'base64' ) ),

QUOTE( aContentName ),

assert( WHICH( 'fold' ) )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

PRINTOUT

(

ANSI( BOLD, '\u{2714} ' ),

ANSI( BOLD, aType:upper() ),

ANSI( DIM, ( ' \u{2014} %s %s ' ):format( COMMA( _size ), PLURAL( _size, 'byte' ) ) )

)

INFO( 'BASE64' )

PRINTOUT()

for aChunk in CHUNK( aHandle ) do

io.stdout:write( aChunk )

end

PRINTOUT()

assert( aHandle:close() )

return true

end

local function HANDLE20BINARY( aContentName, aType, aCharset )

if DISPLAY20BINARY( aContentName, aType, aCharset ) then return true end

local aContentFile = assert( io.open( aContentName, 'rb' ) )

PRINTOUT( ( '20 %s; charset=%s; content-length=%i' ):format( aType, aCharset, _size ) )

for aChunk in CHUNK( aContentFile ) do

assert( io.stdout:write( aChunk ) )

end

assert( aContentFile:close() )

return true

end

local function DISPLAY20APPLICATIONPDF( aContentName, aType, aCharset )

if not ISTTY() then return false end

if not WHICH( 'pdftotext' ) then return false end

local aTextName = TMPNAME( 'pdf', 'txt' )

local aCommand =

( '%s -enc UTF-8 -eol unix -layout -nopgbrk -q - - <%s 1>%s 2>/dev/null' ):format

(

assert( WHICH( 'pdftotext' ) ),

QUOTE( aContentName ),

QUOTE( aTextName )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

return DISPLAY20TEXTPLAIN( aTextName, aType, 'UTF-8' )

end

local function HANDLE20APPLICATIONPDF( aContentName, aType, aCharset )

if DISPLAY20APPLICATIONPDF( aContentName, aType, aCharset ) then return true end

return HANDLE20BINARY( aContentName, aType, aCharset )

end

local function DISPLAY20IMAGE( aContentName, aType, aCharset )

if not ISTTY() then return false end

if not WHICH( 'convert' ) then return false end

if not WHICH( 'jp2a' ) then return false end

local aCommand =

( '%s %s jpg:- 2>/dev/null | jp2a - 2>/dev/null' ):format

(

assert( WHICH( 'convert' ) ),

QUOTE( aContentName ),

assert( WHICH( 'jp2a' ) )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

PRINTOUT

(

ANSI( BOLD, '\u{2714} ' ),

ANSI( BOLD, aType:upper() ),

ANSI( DIM, ( ' \u{2014} %s %s ' ):format( COMMA( _size ), PLURAL( _size, 'byte' ) ) )

)

INFO( 'ASCII' )

PRINTOUT()

for aLine in aHandle:lines() do

PRINTOUT( NOANSI( aLine ) )

end

assert( aHandle:close() )

PRINTOUT()

return true

end

local function HANDLE20IMAGE( aContentName, aType, aCharset )

if DISPLAY20IMAGE( aContentName, aType, aCharset ) then return true end

return HANDLE20BINARY( aContentName, aType, aCharset )

end

local function LANGUAGE( aFileName )

if not WHICH( 'franc' ) then return nil end

local aCommand =

( '%s --min-length 1024 < %s 2>/dev/null' ):format

(

assert( WHICH( 'franc' ) ),

QUOTE( aFileName )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

local aLanguage = assert( aHandle:read() )

assert( aHandle:close() )

if aLanguage and 'und' == aLanguage then aLanguage = nil end

return aLanguage

end

local function DISPLAYIMAGEDATALINK( aScheme, aLink, aDescription )

if 'data:image/png;base64,' ~= aLink:sub( 1, 22 ) then return false end

if not WHICH( 'base64' ) then return false end

if not WHICH( 'convert' ) then return false end

if not WHICH( 'jp2a' ) then return false end

local aType = assert( aLink:match( '^data:(%w+/[%w.+-]+);' ) )

local aSubType = assert( aLink:match( '^data%:image%/([%w.+-]+)%;base64%,' ) )

local someData = assert( aLink:sub( 23 ) )

local aDataName = TMPNAME( 'data', aSubType )

local aCommand =

( '%s %s | %s --decode 2>/dev/null 1>%s' ):format

(

WHICH( 'printf' ),

QUOTE( someData ),

WHICH( 'base64' ),

QUOTE( aDataName )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

local aDataFile = assert( io.open( aDataName, 'rb' ) )

local aSize = assert( aDataFile:seek( 'end' ) )

assert( aDataFile:close() )

local aCommand =

( '%s %s jpg:- 2>/dev/null | jp2a --border --width=32 - 2>/dev/null' ):format

(

assert( WHICH( 'convert' ) ),

QUOTE( aDataName ),

assert( WHICH( 'jp2a' ) )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

PRINTOUT( aDescription )

for aLine in aHandle:lines() do

PRINTOUT( NOANSI( aLine ) )

end

assert( aHandle:close() )

PRINTOUT

(

ANSI

(

DIM,

( '%s \u{2014} %s %s \u{2014} ascii' ):format

(

aType:lower(),

COMMA( aSize ),

PLURAL( aSize, 'byte' )

)

)

)

return true

end

local _datalinkhandles = { image = DISPLAYIMAGEDATALINK }

local function DISPLAYDATALINK( aScheme, aLink, aDescription )

local aType = assert( aLink:match( '^data:(%w+/[%w.+-]+);' ) )

local aMainType = aType:match( '^(%w+)/' )

local aHandler = _datalinkhandles[ aType ] or _datalinkhandles[ aMainType ]

if aHandler and aHandler( aScheme, aLink, aDescription ) then return true end

PRINTOUT

(

( '%s %s' ):format

(

ANSI( UNDERLINE, ( '%s:%s' ):format( aScheme, aType ) ),

aDescription

)

)

return true

end

local _linkhandlers = { data = DISPLAYDATALINK }

local function DISPLAYLINK( aLine )

if '=> ' ~= aLine:sub( 1, 3 ) then return false end

local aLine = aLine:sub( 4 )

local aLink = aLine:match( '^(%S+)' )

local aDescription = aLine:sub( aLink:len() + 2 )

local aScheme = aLink:match( '^([%w.+-]+):' )

local aHandler = _linkhandlers[ aScheme ]

if aHandler and aHandler( aScheme, aLink, aDescription ) then return true end

PRINTOUT( ( '%s %s' ):format( ANSI( UNDERLINE, aLink ), aDescription ) )

return true

end

local function DISPLAYLINE( aLine )

aLine = NOANSI( aLine )

if not DISPLAYLINK( aLine ) then PRINTOUT( aLine ) end

end

DISPLAY20TEXTPLAIN = function( aContentName, aType, aCharset )

if not ISTTY() then return false end

local aFileName = TMPNAME( 'content.utf', 'txt' )

local aCommand =

( '%s --from-code=%s --to-code=UTF-8 < %s 1> %s 2>/dev/null' ):format

(

assert( WHICH( 'iconv' ) ),

QUOTE( aCharset ),

QUOTE( aContentName ),

QUOTE( aFileName )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

local aCommand =

( '%s -l -w -m < %s 2>/dev/null' ):format

(

assert( WHICH( 'wc' ) ),

QUOTE( aFileName )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

local aDescription = assert( aHandle:read() )

assert( aHandle:close() )

local someLines, someWords, someChars = aDescription:match( '^%s-(%d+)%s-(%d+)%s-(%d+)%s-$' )

someLines = tonumber( someLines )

someWords = tonumber( someWords )

someChars = tonumber( someChars )

local someBytes = ''

if _size ~= someChars then someBytes = ( ', %s %s ' ):format( COMMA( _size ), PLURAL( _size, 'byte' ) ) end

local aLabel =

( ' \u{2014} %s %s, %s %s, %s %s%s' ):format

(

COMMA( someLines ),

PLURAL( someLines, 'line' ),

COMMA( someWords ),

PLURAL( someLines, 'word' ),

COMMA( someChars ),

PLURAL( someLines, 'character' ),

someBytes

)

PRINTOUT( ANSI( BOLD, '\u{2714} ' ), ANSI( BOLD, aType:upper() ), ANSI( DIM, aLabel ) )

local aLanguage = ( LANGUAGE( aFileName ) or '' ):upper()

INFO( ( 'UTF-8 %s' ):format( aLanguage ) )

PRINTOUT()

for aLine in assert( io.open( aFileName, 'r' ) ):lines() do

DISPLAYLINE( aLine )

end

PRINTOUT()

return true

end

local function HANDLE20TEXTPLAIN( aContentName, aType, aCharset )

if DISPLAY20TEXTPLAIN( aContentName, aType, aCharset ) then return true end

local aContentFile = assert( io.open( aContentName, 'rb' ) )

PRINTOUT( ( '20 %s; charset=%s; content-length=%i' ):format( aType, aCharset, _size ) )

for aChunk in CHUNK( aContentFile ) do

assert( io.stdout:write( aChunk ) )

end

assert( aContentFile:close() )

return true

end

local _handlers20 =

{

[ 'application/pdf' ] = HANDLE20APPLICATIONPDF,

[ 'image' ] = HANDLE20IMAGE,

[ 'text/plain' ] = HANDLE20TEXTPLAIN

}

local function HANDLE20( aResponseName, aStatusName )

local aFile = assert( io.open( aStatusName, 'r' ) )

local aLine = assert( aFile:read() )

assert( aLine )

assert( aFile:close() )

local aResponseType = assert( aLine:match( '^20 (.+)$' ) )

assert( aResponseType )

assert( 0 ~= aResponseType:len() )

assert( 1024 >= aResponseType:len() )

assert( aResponseType == aResponseType:lower() )

local _, _, _, _, anExtension = URL()

local aContentName = TMPNAME( 'content', anExtension )

local aCommand =

( '%s 1d < %s 1>%s 2>/dev/null' ):format

(

assert( WHICH( 'sed' ) ),

QUOTE( aResponseName ),

QUOTE( aContentName )

)

LOGCMD( aCommand )

assert( os.execute( aCommand ) )

local aContentFile = assert( io.open( aContentName, 'rb' ) )

_size = assert( aContentFile:seek( 'end' ) )

assert( aContentFile:seek( 'set' ) )

assert( aContentFile:close() )

local aCommand =

( '%s --brief --mime-type --mime-encoding %s 2>/dev/null' ):format

(

assert( WHICH( 'file' ) ),

QUOTE( aContentName )

)

LOGCMD( aCommand )

local aHandle = assert( io.popen( aCommand, 'r' ) )

local aContentType = assert( aHandle:read() )

assert( aContentType )

assert( 0 ~= aContentType:len() )

assert( 1024 >= aContentType:len() )

assert( aHandle:close() )

local aType = aContentType:match( '^(%w+/[%w.+-]+); ' )

assert( aType )

assert( 0 ~= aType:len() )

assert( 32 >= aType:len() )

local aMainType = aType:match( '^(%w+)/' )

assert( aMainType )

assert( 0 ~= aMainType:len() )

assert( 16 >= aMainType:len() )

local aCharset = aContentType:match( 'charset=([%w-]+)' )

assert( aCharset )

assert( 0 ~= aCharset:len() )

assert( 16 >= aCharset:len() )

local aHandler = _handlers20[ aType ] or _handlers20[ aMainType ] or HANDLE20BINARY

if not aResponseType:find( aContentType, 1, true ) then WARNING( 'INCONSISTENT CONTENT' ) assert( false ) end

aHandler( aContentName, aType, aCharset )

return aContentName

end

local function DISPLAY30( aLink )

if not ISTTY() then return end

PRINTOUT( ANSI( BOLD, '\u{27A1} REDIRECT' ) )

PRINTOUT()

DISPLAYLINE( ( '=> %s' ):format( aLink ) )

PRINTOUT()

end

local function HANDLE30( aResponseName, aStatusName )

local aFile = assert( io.open( aStatusName, 'r' ) )

local aLine = assert( aFile:read() )

assert( aLine )

assert( aFile:close() )

local aLink = assert( aLine:match( '^30 (.+)$' ) )

assert( 0 ~= aLink:len() )

assert( 1024 >= aLink:len() )

assert( not aLink:find( '%s' ) )

assert( aLink == aLink:lower() )

DISPLAY30( aLink )

if ISTTY() then return end

PRINTOUT( aLine )

end

local function DISPLAY40( aDescription )

if not ISTTY() then return end

PRINTOUT( ANSI( BOLD, '\u{2716} ERROR' ) )

PRINTOUT()

PRINTOUT( aDescription )

PRINTOUT()

end

local function HANDLE40( aResponseName, aStatusName )

local aFile = assert( io.open( aStatusName, 'r' ) )

local aLine = assert( aFile:read() )

assert( aLine )

assert( aFile:close() )

local aDescription = assert( aLine:match( '^40 (.+)$' ) )

assert( aDescription )

assert( 0 ~= aDescription:len() )

assert( 1024 >= aDescription:len() )

DISPLAY40( aDescription )

if ISTTY() then return end

PRINTOUT( aLine )

end

local function TIMESTAMP()

if not ISTTY() then return end

if not WHICH( 'date' ) then return end

local aCommand =

( "%s -u +'%%Y-%%m-%%dT%%H:%%M:%%SZ' 2>/dev/null" ):format

(

assert( WHICH( 'date' ) )

)

LOGCMD( aCommand )