Technical Documentation

Introduction

The Web API Bridge receives Web API calls as HTTP requests, which are translated into SQL Stored Procedure calls that are then invoked on either a local or remote MySQL server.

The Web API Bridge determines the MySQL server to connect to by performing a DNS TXT entry lookup. For example, if the domain of the API server is 'api.webapibridge.org', then a TXT entry lookup is performed on 'db.api.webapibridge.org'.

api.webapibridge.org → db.api.webapibridge.org

The format of the text entry is the name of the database without any numeral version numbers, the '@' symbol, then a comma separated list of hostnames.

webapibridge@db1.webapibridge.org,db2.webapibridge.org,...

Apart from DNS entries, the only configuration required is that x509 certificates and keys used for authentication with remote MySQL servers must be stored within the 'SSL_BASE' directory specified. Additionally, any targeted MySQL databases must also implement the following stored function, which allows the Web API Bridge to discover what parameters exported stored procedures expect.

Note, as indicated by the function implementation below, only stored procedures with a security type of 'DEFINER' and that have a comment of 'EXPORT' can be called.

DROP   FUNCTION RetrieveParametersFor;
DELIMITER //
CREATE FUNCTION RetrieveParametersFor
(
    $database  CHAR(64),
    $name      CHAR(99)
)
RETURNS blob
READS SQL DATA
BEGIN

    DECLARE $ret BLOB;

    SELECT
        param_list

    INTO
        $ret

    FROM     mysql.proc
    WHERE    db            =  $database
    AND      name          =  $name
    AND      type          = 'PROCEDURE'
    AND      security_type = 'DEFINER'
    AND      comment       = 'EXPORT'
    ORDER BY modified DESC LIMIT 1;

    return $ret;

END
//
DELIMITER ;

Configuration

As, conceptually, the Web API Bridge is not an authentication or authorisation layer, the Web API Bridge connects to any MySQL databases using the credentials "public" and "public", and only requires the 'EXECUTE' priviledge. However, best practise is that any connections to remote MySQL databases should also be authorised and ecrypted using x509 certificates.

GRANT EXECUTE ON *.* TO 'public'@'<Web API Brige IP address>' IDENTIFIED BY 'public';

The Web API Bridge configuration file allows the user to override the username and password used, as well as the location that x509 certificates (and keys) are stored within.

configuration/conf.php
<?php

define( "DB_USERNAME", "public" );
define( "DB_PASSWORD", "public" );
define( "SSL_BASE",    "/etc/mysql/ssl/" );

To enable experimental code paths for specific api domains, edit the following by adding API domains to the array and mapping them to TRUE.

define( "EXPERIMENTAL", array( "api.example.com" => FALSE ) );

Underneath the 'SSL_BASE' directory should be a directory for each database server that is connected to. The name of the directory should match the fully qualified domain name of the server. Within that directory should be a client certificate file, key file, and a a server certificate authority (CA) file. For example:

/etc/mysql/ssl/db.webapibridge.org
/etc/mysql/ssl/db.webapibridge.org/client-cert.pem
/etc/mysql/ssl/db.webapibridge.org/client-key.pem
/etc/mysql/ssl/db.webapibridge.org/servera-ca.pem

Apache Configuration

For each API server domain, an Apache configuration is required to specify which domains are allowed to access the API server by setting the 'Access-Control-Allow-Origin'.

<VirtualHost *:80>

    ServerName  api.%DOMAIN%
    ServerAdmin webmaster@%DOMAIN%

    DocumentRoot %DOCUMENT_ROOT%/WebAPIBridge/latest/webapibridge/sbin 

    #   Uncomment to use specific database
    #
    #SetEnv USE_DATABASE                   <database name>@<database hostname>

    #   Uncomment to enable EXPERIMENTAL code paths
    #
    #SetEnv USE_EXPERIMENTAL               TRUE

    #
    #   Uncomment to allow /api/auth/oauth2/token return mingled sessionid/csrf token
    #
    #SetEnv USE_OAUTH2_TOKEN               TRUE

    #   Uncomment to not set server side sessionid cookie
    #
    #SetEnv USE_SESSION_COOKIE             FALSE

    #   Uncomment to only log level 0 messages
    #
    #SetEnv SHOW_LOG_TO_LEVEL              0

    #
    #   Uncomment to log request parameters
    #
    #SetEnv LOG_REQUEST_PARAMETERS         TRUE

    #
    #	Uncomment to log actual stored procedure calls and number of rows returned
    #
    #SetEnv LOG_STORED_PROCEDURE_CALL      TRUE

    #
    #   Uncomment to log error messages returned
    #
    #SetEnv LOG_ERRORS                     TRUE

    <Directory %DOCUMENT_ROOT%/WebAPIBridge/latest/webapibridge/sbin/>
        php_value auto_prepend_file "%DOCUMENT_ROOT%/WebAPIBridge/latest/webapibridge/configuration/conf.php"
    </Directory>

    <Directory %DOCUMENT_ROOT%/WebAPIBridge/latest/webapibridge/sbin/>
        RewriteEngine On
        RewriteBase /
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteRule /* index.php
    </Directory>

    ErrorLog /var/log/apache2/api.%DOMAIN%.log

    ErrorLogFormat "[%t] [pid %P] [XForwardFor %{X-Forwarded-For}i] [Client %a] %M"

    # Possible values include: debug, info, notice, warn, error, crit,
    # alert, emerg.
    LogLevel warn

    CustomLog /var/log/apache2/access.log combined

    #ErrorDocument 404 /index.php

    Header set Access-Control-Allow-Origin      "https://%DOMAIN%"
    Header set Access-Control-Allow-Methods     "POST, GET, PUT, OPTIONS, PATCH, DELETE"
    Header set Access-Control-Allow-Credentials "true"
    Header set Access-Control-Allow-Headers     "X-Session-ID, X-CSRF-Token"
    Header set Strict-Transport-Security        "max-age=31536000"
    Header set Content-Security-Policy          "default-src 'none'; upgrade-insecure-requests;"

</VirtualHost>

Google Pub Sub configuration

The Web API Bridge is able to log API request meta-information to a Google Pub Sub topic.

Implementation

The Web API Bridge is currently implemented in PHP and is intended for use with Apache2, although it can be invoked on the PHP command-line for testing purposes. If appropriately configured, the Web API Bridge is able to log to a Google Pub Sub topic. Currently, this is facilitated by using the Google client libraries which are located in the 'dep/vendor' directory.

<?php

require __DIR__ . '/dep/vendor/autoload.php';

The main Web API Bridge also uses the following generic dependecies whose implementations are described in the appendices.

include_once(          "CSV.php" );
include_once(      "strings.php" );
include_once(      "jstream.php" );
include_once(          "log.php" );
include_once(          "ssl.php" );
include_once(        "mysql.php" );
include_once(        "input.php" );
include_once( "experimental.php" );

The 'main' function is invoked everytime a Web API request is received. It carries out the following key steps:

  1. Deteremine environment and filter input
  2. If a tunnelling request, call the tunnelled endpoint and return its response
  3. Translate the request URI into a provisional stored procedure name
  4. Determine the domain name to use for DNS queries
  5. Retrieve target database information from DNS (or local cache)
  6. Determine the version of the database to query
  7. Map any passed HTTP parameters to stored procedure arguments
  8. Call the stored procedure
  9. If the stored procedure was an authentication request it stores the returned session id in a cookie
  10. A response object is contructed
  11. A response object is returned as either CSV of JSON
  12. Meta-information about the call is logged to a Google Pub Sub topic.
$args = isset( $argv ) ? $argv : array();

main( $args );

function main( $argv )
{
    switch( $_SERVER['REQUEST_METHOD'] )
    {
    case "OPTIONS":
    case "PUT":
    case "PATCH":
    case "DELETE":
        NeoLog( "Ignoring unsupported method " . $_SERVER['REQUEST_METHOD'] . ":" . $_SERVER["REDIRECT_URL"] . "?" . urldecode( file_get_contents( 'php://input') ) );
        break;

    default:
        $start = microtime( TRUE );
        $delta = 0;
        $use_buffered = ( "TRUE" == getenv( "USE_GOOGLE_PUB_SUB" ) );

        if
        (
            !string_has_prefix( $_SERVER["REDIRECT_URL"], "/auth/" )
            &&
            !string_has_prefix( $_SERVER["REDIRECT_URL"], "/api/"  )
            &&
            !string_has_prefix( $_SERVER["REDIRECT_URL"], "/raw/"  )
        )
        {
            NeoLog( "Ignoring request:" . $_SERVER["REDIRECT_URL"] . "?" . urldecode( file_get_contents( 'php://input') ) );
            exit();
        }
        else
        {
            $method = sprintf( "%4s", $_SERVER['REQUEST_METHOD'] );

            if ( "TRUE" == getenv( "LOG_REQUEST_PARAMETERS" ) )
            {
                $password = null;
                if ( array_key_exists( "password", $_REQUEST ) )
                {
                    $password             = $_REQUEST["password"];
                    $_REQUEST["password"] = "[hidden]";
                }

                $request = http_build_query( $_REQUEST );
            
                NeoLog( "Starting new request, $method " . $_SERVER["REDIRECT_URL"] . "?" . urldecode( $request ) );

                if ( $password ) $_REQUEST["password"] = $password;
            }
            else
            {
                NeoLog( "Starting new request, $method " . $_SERVER["REDIRECT_URL"] );
            }
        }
        NeoLogIn();

        $environment = DetermineEnvironment         ( $argv                                                                         );
        $sp_name     = TranslateSPName              ( $environment["redirect_url"]                                                  );
                       CheckIfTunnelRequest         ( $sp_name,     $environment                                                    );
        $db_domain   = DetermineDatabaseLookupDomain( $environment["server_name"]                                                   );
        $db_info     = LookupDatabaseInfo           ( $db_domain                                                                    );
        $db_version  = LookupDatabaseVersion        ( $db_info                                                                      );
                       CheckIfDownloadRequest       ( $db_info,     $db_version, $sp_name, $environment                             );
        $sp_call     = MapRequestToSPCall           ( $db_info,     $db_version, $sp_name, $environment["request"]                  );
        $ret         = CallStoredProcedure          ( $db_info,     $db_version, $sp_name, $sp_call, $environment                   );
                       SetSessionIDCookie           ( $sp_name,     $ret                                                            );
        $response    = CreateResponse               ( $environment, $ret, ($delta = ceil( (microtime( TRUE ) - $start) * 1000000 )) );
                       OutputResponse               ( $sp_name,     $response, $environment["request"], $use_buffered               );
                       LogToPubSub                  ( $environment, $db_info, $db_version, $sp_call, $response, $delta              );

        if ( "TRUE" == getenv( "LOG_STORED_PROCEDURE_CALL" ) )
        {
            if ( is_a( $ret, 'Results' ) )
            {
                $count = $ret->numRows();
            
                NeoLogError( "Called: " . $ret->sqlQuery . ": returned " . $count . " rows" );
            }
        }

        NeoLogOut();
        NeoLog( "Finishing:" . $_SERVER["REDIRECT_URL"] . " $delta microseconds" );
    }
}

The following sections describes the implementations of these called functions in detail.

Determine Environment

function DetermineEnvironment( $argv )
{
    NeoLog( "Determining environment" );
    NeoLogIn();

    $environment = null;

    if ( "cli" != php_sapi_name() )
    {
        NeoLog( "Determining envionrment from Apache" );
        $environment = DetermineEnvironmentFromApache();
    }
    else
    {
        NeoLog( "Determining envionrment from command-line arguments" );
        $environment = DetermineEnvironmentFromArguments( $argv );
    }

    if ( ("" == $environment["server_name"]) || ("" == $environment["redirect_url"]) )
    {
        NeoLog( "Invalid environment, no SERVER_NAME or REDIRECT_URL." );
        NeoLog( "Commandline usage:" );
        NeoLog( "php index.php --server-name api.example.com --redirect-url /api/users/example/ --request '{\"param1\":\"value\",...}'" );
        exit;
    }

    if ( !defined( "DB_USERNAME" ) ) define( "DB_USERNAME", "public" );
    if ( !defined( "DB_PASSWORD" ) ) define( "DB_PASSWORD", "public" );
    if ( !defined( "SSL_BASE"    ) ) define( "SSL_BASE", "/etc/mysql/ssl/" );

    NeoLog( "Configuration: username: " . DB_USERNAME . "; password: " . DB_PASSWORD . "; ssl_base: " . SSL_BASE );

    //
    //  Setup use of CSRF Token
    //

    if ( "" != array_get( $environment['request'], "wab_csrf_token" ) )
    {
        $environment['request']["sid"]
        =
        substr( array_get( $environment['request'], "sid"            ), 0, 32 )
        .
        substr( array_get( $environment['request'], "wab_csrf_token" ), 0, 32 );
    }

    NeoLogOut();

    return $environment;
}
function DetermineEnvironmentFromApache()
{
    NeoLogIn();

    $input        = urldecode( file_get_contents( 'php://input' ) );
    $server_name  = "";
    $redirect_url = "";
    $requested    = "";

    if ( isset( $_SERVER ) && array_key_exists( "SERVER_NAME", $_SERVER ) )
    {
        $server_name = $_SERVER["SERVER_NAME"];
    }

    if ( isset( $_SERVER ) && array_key_exists( "REDIRECT_URL", $_SERVER ) )
    {
        $redirect_url = CanonicalisePath( $_SERVER["REDIRECT_URL"] );
    }

    if ( isset( $_REQUEST ) )
    {
        NeoLog( "Request is set" );
        $request = string_has_prefix( $redirect_url, "/raw/" ) ? $_REQUEST : Input::FilterInput( $_REQUEST, null );
    }

    if ( "{" == substr( $input, 0, 1 ) )
    {
        if ( NULL !== json_decode( $input ) )
        {
            NeoLog( "Added JSON to request" );
            $request["json"] = $input;
        }
    }

    NeoLog( "Checking headers for API Key" );
    NeoLogIn();
    foreach( apache_request_headers() as $header => $value )
    {
        $_value = Input::Filter( $value );

        if ( "Accept" == $header && !array_key_exists( "accept", $request ) )
        {
            $request["accept"]         = $_value;
            NeoLog( "request['accept'] = $_value" );
        }
        else
        if ( "Authorization" == $header && !array_key_exists( "authorization", $request ) )
        {
            $request["authorization"]         = $_value;
            NeoLog( "request['authorization'] = $_value" );

            if ( !array_key_exists( "sid", $request ) )
            {
                $request["sid"]         = trim( str_replace( 'Bearer', '', $_value ) );
                NeoLog( "request['sid'] = $_value (Bearer)" );
            }
        }
        else
        if ( "X-Access-ID" == $header && !array_key_exists( "accessid", $request ) )
        {
            $request["accessid"]         = $_value;
            NeoLog( "request['accessid'] = $_value" );
        }
        else
        if ( "X-Api-Key" == $header && !array_key_exists( "apikey", $request ) )
        {
            $request["apikey"]         = $_value;
            NeoLog( "request['apikey'] = $_value" );
        }
        else
        if ( "X-Auth-Token" == $header && !array_key_exists( "auth_token", $request ) )
        {
            $request["auth_token"]         = $_value;
            NeoLog( "request['auth_token'] = $_value" );
        }
        else
        if ( "X-CSRF-Token" == $header && !array_key_exists( "wab_csrf_token", $request ) )
        {
            $request["wab_csrf_token"]         = $_value;
            NeoLog( "request['wab_csrf_token'] = $_value" );
        }
        else
        if ( "X-Session-ID" == $header && !array_key_exists( "sid", $request ) )
        {
            $request["sid"]         = $_value;
            NeoLog( "request['sid'] = $_value" );
        }
    }
    NeoLogOut();
    NeoLogOut();

    return array
    (
        "server_name"  => $server_name,
        "redirect_url" => $redirect_url,
        "request"      => $request
    );
}

function CanonicalisePath( $constant )
{
    if ( '.php' == substr( $constant, -4 ) )
    {
        $constant = dirname( $constant );
    }

    if ( '/' != substr( $constant, -1 ) )
    {
        $constant .= "/";
    }

    return $constant;
}
function DetermineEnvironmentFromArguments( $argv )
{
    $server_name  = "";
    $redirect_url = "";
    $request      = "";

    $next_is_server_name  = 0;
    $next_is_redirect_url = 0;
    $next_is_request      = 0;
    foreach( $argv as $arg )
    {
        if ( $next_is_server_name )
        {
            $server_name         = $arg;
            $next_is_server_name = 0;
        }
        else
        if ( $next_is_redirect_url )
        {
            $redirect_url         = $arg;
            $next_is_redirect_url = 0;
        }
        else
        if ( $next_is_request )
        {
            $request         = json_decode( $arg, TRUE );
            $next_is_request = 0;
        }
        else
        {
            switch ( $arg )
            {
            case "--server-name":
                $next_is_server_name = 1;
                break;

            case "--redirect-url":
                $next_is_redirect_url = 1;
                break;

            case "--request":
                $next_is_request = 1;
                break;
            }
        }
    }

    if ( !$request ) $request = array();

    return array
    (
        "server_name"  => $server_name,
        "redirect_url" => $redirect_url,
        "request"      => $request
    );
}

Translate stored procedure name

The stored procedure to be called is a simple mapping from the URL.

function TranslateSPName( $redirect_url )
{
    NeoLog( "Translating stored procedure name from url" );

    $bits = explode( '/', $redirect_url );

    if ( "" == $bits[0] ) $bits = array_slice( $bits, 1 );

    switch ( $bits[0] )
    {
    case 'api':
        $sp_name = trim( implode( '_', array_slice( $bits, 1 ) ), '_' );
        break;

    case 'auth':
        $sp_name = trim( implode( '_', array_slice( $bits, 0 ) ), '_' );
        break;

    case 'download':
        $sp_name = 'download';
        break;

    case 'raw':
        $sp_name = trim( implode( '_', array_slice( $bits, 0 ) ), '_' );
        break;

    case 'tunnel':
        $sp_name = 'tunnel';
        break;

    default:
        http_response_code( 402 );
        //header( "Content-Type: text/plain" );
        //echo "This is a Web API Bridge HTTP endpoint -- see https://www.webapibridge.org";
        exit;
    }

    return $sp_name;
}

Check if tunnel request

function CheckIfTunnelRequest( $sp_name, $environment )
{
    if ( "tunnel" != $sp_name )
    {
        //
        //  This is mysteriously not being executed...
        //

        NeoLog( "Checking if tunnel request - NO" );
    }
    else
    {
        NeoLog( "Checking if tunnel request - YES" );
        NeoLogIn();
        Tunnel( $environment );
        NeoLogOut();
    }
}
function Tunnel( $environment )
{
    $request       = $environment['request'];
    $method        = array_get( $request, "wab_method"        );
    $authorization = array_get( $request, "wab_authorization" );
    $host          = array_get( $request, "wab_host"          );
    $endpoint      = array_get( $request, "wab_endpoint"      );
    $accept        = array_get( $request, "wab_accept"        );
    $content_type  = array_get( $request, "wab_content_type"  );
    $content64     = array_get( $request, "wab_content64"     );
    $headers       = array_get( $request, "wab_headers"       );

    NeoLog( "WAB tunnel debug: $host$endpoint" );

    if ( ! ($method && $host && $endpoint && $accept && $content_type) )
    {
        header( "Content-Type: text/plain" );

        echo "Error: incomplete headers"         . "\n";
        echo "+ wab_method:       $method"       . "\n";
        echo "+ wab_host:         $host"         . "\n";
        echo "+ wab_endpoint:     $endpoint"     . "\n";
        echo "+ wab_accept:       $accept"       . "\n";
        echo "+ wab_content_type: $content_type" . "\n";
        echo "+ wab_content64:    $content64"    . "\n";
    }
    else
    {
        $curl         = SetupCURL( $method, $authorization, $host, $endpoint, $content_type, $content64, $accept, $headers );
        $response     = curl_exec ( $curl );
        $err          = curl_error( $curl );

        if ( $err )
        {
            header( "Content-Type: text/plain" );
            echo $err;
        }
        else
        {
            header( "Content-Type: $accept" );
            echo $response;
        }
    }

    ob_flush();
    flush();
    exit;
}

function SetupCURL( $method, $authorization, $host, $endpoint, $content_type, $content64, $accept, $headers )
{
    $curl = curl_init();

    $verify_host = 0;
    $verify_peer = 0;
    $verify = ! string_has_suffix( $host, ".local" );

    if ( $verify )
    {
        $verify_host = 1;
        $verify_peer = 1;
    }

    $headers = array
    (
        "Accept: $accept",
        "Content-Type: $content_type",
        "Cache-Control: no-cache"
    );

    if ( "" != $authorization )
    {
        $headers[] = "Authorization: $authorization";
    }

    $url      = $host . $endpoint;
    $content  = base64_decode( $content64 );

    if ( "GET" == $method )
    {
        $url     = $url . "?" . $content;
        $content = "";
    }
    else
    {
        $payload    = array();
        $parameters = explode( "&", $content );
        foreach ( $parameters as $keyval )
        {
            $bits = explode( "=", $keyval );
            $key  = $bits[0];
            $val  = $bits[1];

            $payload[$key] = $val;
        }
        $content = http_build_query( $payload );
    }

    error_log( "WAB Tunnel: $url" );

    curl_setopt_array(
        $curl,
        array
        (
            CURLOPT_URL            => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_ENCODING       => "",
            CURLOPT_MAXREDIRS      => 10,
            CURLOPT_TIMEOUT        => 30,
            CURLOPT_HTTP_VERSION   => CURL_HTTP_VERSION_1_1,
            CURLOPT_CUSTOMREQUEST  => $method,
            CURLOPT_POSTFIELDS     => $content,
            CURLOPT_HTTPHEADER     => $headers,
            CURLOPT_SSL_VERIFYHOST => 0,
            CURLOPT_SSL_VERIFYPEER => 0
        )
    );

    return $curl;
}
static function ExtractParameters( $request )
{
    $parameters = array();

    foreach( $request as $key => $value )
    {
        if ( "wab_" != substr( $key, 0, 4 ) )
        {
            $parameters[$key] = $value;
        }
    }

    return $parameters;
}

Determine database domain

In order to allow a Web API Bridge to act as an API service for arbitrary domains, the hostname (or IP address) of the database server to be connected to, as well as the name of the database instance to be interrogated, is configured using DNS text records.

The prefix 'db.' is added to the API domain called to create the domain that is queried -- for example, 'api.example.com' would become 'db.api.example.com'. If a local domain is called, such as 'api.example.com.local', the prefix 'local-db.' is added to the API domain called, and the '.local' suffix is removed, to create the domain that is queried -- for example, 'api.example.com.local' would become 'local-db.api.example.com'.

function DetermineDatabaseLookupDomain( $server_name )
{
    if ( string_has_suffix( $server_name, ".local" ) )
    {
        $db_domain = "local-db." . str_replace( '.local', '', $server_name );
    }
    else
    {
        $db_domain = "db." . $server_name;
    }

    NeoLog( "Determining database lookup domain name: $db_domain" ); 

    return $db_domain;
}

Lookup database info

function LookupDatabaseInfo( $db_domain )
{
    $db_info = null;
    $db_temp = (object) array( "dbname" => null, "hosts" => null );

    if ( ($database = getenv( "USE_DATABASE" )) )
    {
        $db_info = ExtractDBInfoFromEnvText( $database );
    }
    else
    {
        if ( function_exists( "apcu_exists" ) && apcu_exists( $db_domain ) )
        {
            $db_cached = apcu_fetch( $db_domain );
            $db_name   = $db_cached->dbname;
            $db_host   = $db_cached->hosts[0];

            if ( $db_name && $db_host )
            {
                NeoLog( "Looking up database info: found cached: $db_name@$db_host" );
                $db_info = $db_cached;
            }
        }

        if ( ! $db_info )
        {
            try
            {
                $records = dns_get_record( $db_domain, DNS_TXT );
                $n       = (null != $records) ? count( $records ) : 0;

                if ( 0 < $n )
                {
                    $db_dns = ExtractDBInfoFromDNSRecords( $records );
                }
                else
                {
                    $db_dns = ExtractDBInfoFromDBDomain( $db_domain );
                }

                $db_name = $db_dns->dbname;
                $db_host = $db_dns->hosts[0];

                if ( $db_name && $db_host )
                {
                    NeoLog( "Looking up database info: DNS returned $n records: $db_name@$db_host" );
                    $db_info = $db_dns;
                }

                if ( $db_info && function_exists( "apcu_add" ) )
                {
                    apcu_add( $db_domain, $db_info );
                    NeoLogIn();
                    NeoLog( "Caching: added to cache: $db_domain" );
                    NeoLogOut();
                }
            }
            catch ( Exception $ex )
            {
                NeoLog( "Exception while retrieving from DNS" );
                exit;
            }
        }
    }

    NeoLogIn();
    if ( ! $db_info )
    {
        NeoLog( "Error, Could not determine database information, exiting." );
        exit;
    }
    else
    {
        //  Following will abort if cannot retrieve database connection.
        CheckDatabaseConnection( $db_info );
    }
    NeoLogOut();

    return $db_info;
}
function ExtractDBInfoFromDNSRecords( $records )
{
    foreach ( $records as $record )
    {
        $host    = array_key_exists(    "host", $record ) ? $record[   "host"] : "";
        $class   = array_key_exists(   "class", $record ) ? $record[  "class"] : "";
        $ttl     = array_key_exists(     "ttl", $record ) ? $record[    "ttl"] : "";
        $type    = array_key_exists(    "type", $record ) ? $record[   "type"] : "";
        $txt     = array_key_exists(     "txt", $record ) ? $record[    "txt"] : "";

        if ( $txt )
        {
            return ExtractDBInfoFromDNSText( $txt );
        }
    }

    return null;
}
function ExtractDBInfoFromDNSText( $txt )
{
    $bits = explode( "@", $txt );
        
    switch ( count( $bits ) )
    {
    case 2:
        $dbname = $bits[0];
        $hosts  = explode( ",", $bits[1] );
        break;
    
    case 1:
        $hosts  = explode( ",", $bits[0] );
        break;
    }

    return (object) array( "dbname" => $dbname, "hosts" => $hosts );
}
/*
 *  Important!!! Below code is different to similar code above.
 *  This function is called when the USE_DATABASE environment variable is used.
 *  This may either be: <database>,             e.g., base
 *  or                  <database>@[host1],..., e.g., base@db1.example.com,db2.example.com
 *
 *  In contrast, code above allows a DNS text record to have only hostnames.
 */
function ExtractDBInfoFromEnvText( $txt )
{
    $bits = explode( "@", $txt );
        
    switch ( count( $bits ) )
    {
    case 2:
        $dbname = $bits[0];
        $hosts  = explode( ",", $bits[1] );
        break;
    
    case 1:
        $dbname = $bits[0];
        $hosts  = array( "localhost" );
        break;
    }

    return (object) array( "dbname" => $dbname, "hosts" => $hosts );
}
function ExtractDBInfoFromDBDomain( $db_domain )
{
    $truncated = str_replace( "www.", "", $db_domain );
    $truncated = str_replace( "api-", "", $truncated );
    $truncated = str_replace( "api.", "", $truncated );
    $bits      = explode( ".", $truncated );

    $n = count( $bits );

    for ( $i = 1; $i < $n; $i++ )
    {
        if ( ! IsTLD( $bits[$i], $i ) )
        {
            $dbname = $bits[$i];
            break;
        }
    }

    return (object) array( "dbname" => $dbname, "hosts" => array("localhost") );
}
function IsTLD( $domain_part, $level = 1 )
{
	switch ( $level )
	{
	case "1":
		switch ( $domain_part )
		{
		case "au":
		case "com":
		case "net";
		case "org";
		case "co":
		case "info":
		case "xyz":
		case "local":
			return true;
			
		default:
			return false;
		}
		break;

	case "2":
		switch ( $domain_part )
		{
		case "com":
		case "net";
		case "org";
		case "id":
		case "conf":
			return true;
			
		default:
			return false;
		}
		break;
	
	default:
		return false;
	}
}
function CheckDatabaseConnection( $db_info )
{
    if ( !defined( "DB_HOSTNAME" ) ) define( "DB_HOSTNAME", $db_info->hosts[0] );

    NeoLog( "Checking database connection to: " . $db_info->hosts[0] );
    NeoLogIn();

    $m = MySQLCreate();

    NeoLogOut();

    return TRUE;
}

Determine database version

function LookupDatabaseVersion( $db_info )
{
	$db_version = "";
    $db_name    = "";
    $db_hosts   = implode( ', ', $db_info->hosts );
    $db_host    = $db_info->hosts[0];

    $mysql  = MySQLCreate();
    $tuples = MySQLInfo( $mysql, "SHOW DATABASES" );

    foreach( $tuples as $tuple )
    {
        $tmp = $tuple["Database"];

        if ( string_has_prefix( $tmp, $db_info->dbname ) )
        {
            $db_name = $tmp;
        }
    }
    $db_version = $db_name ? str_replace( $db_info->dbname, "", $db_name ) : $db_version;

    if ( $db_name )
    {
        NeoLog( "Determining target database version: found: $db_name" );
    }
    else
    {
        NeoLog( "Determining target database version: cound not find database for: " . $db_info->dbname );
        exit;
    }

    return $db_version;
}

Check if download request

function CheckIfDownloadRequest( $db_info, $db_version, $sp_name, $environment )
{
    NeoLog( "Checking if tunnel request" );

    if ( "download" != $sp_name )
    {
        //
        //  This is mysteriously not being executed...
        //

        NeoLog( "Checking if download request - NO" );
    }
    else
    {
        NeoLog( "Performing download" );

        NeoLogIn();
        Download( $db_info, $db_version, $environment );
        NeoLogOut();
    }
}
function Download( $db_info, $db_version, $environment )
{
    $request = $environment['request'];
    $db      = $db_info->dbname . $db_version;
    $sid     = array_get( $request, "sid"   );
    $token   = array_get( $request, "token" );

    if ( $token )
    {
        $file = Retrieve( $db, $sid, $token );

        if ( $file )
        {
            $name    = $file->filename;
            $type    = $file->filetype;
            $size    = $file->filesize;
            $base64  = $file->base64;
            $content = base64_decode( $base64 );

            header( "Content-Type: application/octet-stream"                    );
            header( "Content-Length: $size"                                     );
            header( "Content-Disposition: attachment; filename=\"$name\""       );
            header( "Pragma: public"                                            );
            header( "Cache-Control: must-revalidate, post-check=0, pre-check=0" );
            echo $content;
        }
        else
        {
            header( "Content-Type: text/plain" );
            echo "File not found";
        }
    }
    else
    {
        header( "Content-Type: text/plain" );
        echo "No file specified";
    }

    ob_flush();
    flush();
    exit;
}
function Retrieve( $db, $sid, $token )
{
    $sp_call = (object) array
    (
        "proc_name" => "Base_Files_Retrieve_By_Token",
        "arguments" => array( $sid, $token )
    );

    $ret = MySQLProcedure( $db, $sp_call, $procedure );

    //NeoLog( "Retrieve: CALL $procedure" );

    return array_key_exists( 0, $ret ) ? $ret[0] : null;
}

Determine Stored Procedure Call

function MapRequestToSPCall( $db_info, $db_version, $sp_name, $request )
{
    $sp_call   = null;
    $proc_name = null;
    $arguments = array();

    if ( "multiselect" != $sp_name )
    {
        NeoLog( "Determine Stored Procedure Call" );
        NeoLogIn();

        $db = $db_info->dbname . $db_version;

        //
        //  Create list of provisional sp names.
        //

        $provisional[] = $sp_name;
        if ( string_has_suffix( $sp_name, "_csv" ) )
        {
            $provisional[] = preg_replace( "/_csv\z/", "", $sp_name );
        }
        $provisional[] = $provisional[count($provisional)-1] . "_retrieve";

        //
        //  Use first procedure found that matches provisional name.
        //

        $result = null;
        foreach( $provisional as $prov )
        {
            $sql = "RetrieveParametersFor( '$db', '$prov' )";
            
            $result = MySQLFunction( $db, $sql );

            if ( null !== $result )
            {
                $proc_name = $prov;
                break;
            }
        }

        if ( !$proc_name )
        {
            NeoLog( "Could not find procedure for: " . $sp_name );
            return null;
        }
        else
        {
            $parameters = ConvertParametersToDictionary( $result );

            foreach ( $parameters as $parameter )
            {
                // Strip of leading '$' and make lowercase.
                $parameter_name = str_replace( '$', '', $parameter );
                $value          = null;

                if ( "wab_remote_address" == $parameter_name )
                {
                    $value = $_SERVER["REMOTE_ADDR"];
                }
                else
                if ( "sid" == strtolower( $parameter_name ) )
                {
					$sid         = array_get( $request, "sid" );
					$remote_addr = GetRemoteAddress();

                    if ( Experimental() )
                    {
						$value = $sid . "@" . $remote_addr;
					}
					else
					{
						$value = $sid;
					}
                }
                else
                if ( "apikey" == strtolower( $parameter_name ) )
                {
                    $value = array_get( $request, "apikey" ) . "@" . $_SERVER["REMOTE_ADDR"];
                }
                else
                if ( array_key_exists( $parameter_name, $request ) )
                {
                    $value = array_get( $request, $parameter_name );
                }
                else
                if ( array_key_exists( strtolower( $parameter_name ), $request ) )
                {
                    $value = array_get( $request, strtolower( $parameter_name ) );
                }
                else
                {
                    if ( Experimental() )
                    {
                        $value = null;
                    }
                    else
                    {
                        $value = "";
                    }
                }

                $arguments[] = $value;
            }
        }

        NeoLogOut();
    }

    return (object) array( "proc_name" => $proc_name, "arguments" => $arguments );
}

Get Remote Address

function GetRemoteAddress()
{
	if ( array_key_exists( "X-Forwarded-For", $_SERVER ) && $_SERVER["X-Forwarded-For"] )
	{
		return strtok( $_SERVER["X-Forwarded-For"], "," );
	}
	else
	{
		return $_SERVER["REMOTE_ADDR"];
	}
}

Convert parameters to dictionary

function ConvertParametersToDictionary( $string )
{
    $parameters = array();
    $bits       = explode( ",", trim( $string ) );
    
    foreach ( $bits as $parameter )
    {
        $parts = explode( " ", trim( $parameter ) );
        
        $parameters[] = $parts[0];

        if ( defined( "VERBOSE" ) && VERBOSE ) error_log( $parts[0] . " " . $parts[1] );
    }
    
    return $parameters;
}

Call stored procedure

function CallStoredProcedure( $db_info, $db_version, $sp_name, $sp_call, $environment )
{
    $ret = null;

    if ( $sp_call )
    {
        NeoLog( "Call Stored Procedure" );
        NeoLogIn();

        $db = $db_info->dbname . $db_version;

        if ( "multiselect" == $sp_name )
        {
            $ret = Multiselect   ( $db_info, $db_version, $environment );
        }
        else
        {
            $ret = MySQLProcedureResults( $db, $sp_call );
        }

        NeoLogOut();
    }

    return $ret;
}
function Multiselect( $db_info, $db_version, $environment )
{
    $use_new        = true;

    $set            = array();
    $db             = $db_info->dbname . $db_version;
    $kinds          = explode( ',', array_get( $environment['request'], "kinds" ) );
    $sid            = array_get( $environment['request'], "sid"    );
    $filter         = array_get( $environment['request'], "filter" );

    #
    #   Create pseudo-request for select call
    #

    $entity_encoded      = array_get( $environment['request'], "json"   );
    $json                = html_entity_decode( $entity_encoded );
    $request             = (array) json_decode( $json );
    $request['filter']   = $filter;
    $request['sid']      = array_get( $environment['request'], "sid"    );

    foreach ( $kinds as $kind )
    {
        $sp_call = null;

        $bits = explode( ":", $kind );
        switch ( count( $bits ) )
        {
        case 1:
            $id          = "";
            $select_name = $bits[0];
            break;

        case 2:
            $id          = explode( ':', $kind )[0];
            $select_name = explode( ':', $kind )[1];
            break;

        default:
            break;
        }

        if ( $select_name )
        {
            $proc_name = "selects_$select_name";

            if ( $use_new )
            {
                $request['id'] = $id;
                $sp_call       = MapRequestToSPCall( $db_info, $db_version, $proc_name, $request );
                $tuples        = MySQLProcedure( $db, $sp_call, $procedure );
            }
            else
            {
                $arguments   = array();
                $arguments[] = $sid;
                $arguments[] = $id;
                $arguments[] = "";
                $arguments[] = $filter;
            
                $sp_call = (object) array
                (
                    "proc_name" => $proc_name,
                    "arguments" => $arguments
                );

                $tuples = MySQLProcedure( $db, $sp_call, $procedure );
            }

            if ( is_array( $tuples ) )
            {
                $set[] = (object) array( "id" => $id, "name" => $kind, "tuples" => $tuples, "call" => $procedure );
            }
            else
            {
                $set[] = (object) array( "id" => $id, "name" => $kind,  "error" => $tuples, "call" => $procedure );
            }
        }
    }

    return $set;
}

Set session ID cookie

function SetSessionIDCookie( $sp_name, $ret )
{
    NeoLog( "Existing sessionid: " . array_get( $_COOKIE, "sid" ) );

    NeoLog( "USE_SESSION_COOKIE: " . getenv( "USE_SESSION_COOKIE" ) );

    if ( "FALSE" != getenv( "USE_SESSION_COOKIE" ) )
    {
        $is_local = ("8443" == $_SERVER['SERVER_PORT']);

        if ( !$is_local ) $is_local = string_has_suffix( $_SERVER['SERVER_NAME'], '.test' );

        if ( "auth_login" == $sp_name )
        {
            if ( is_a( $ret, 'Results' ) )
            {
                $tuple     = $ret->getFirst(); // Retrieve first tuple.
                $sessionid = $tuple->sessionid;
                $cookie    = "Set-Cookie: sid=";
                $cookie    = $cookie . $sessionid;

                if ( $is_local )
                {
                    // SameSite is causing issues with local API server
                    // that uses self-signed certificates.

                    $cookie = $cookie . "; path=/; HttpOnly;secure";
                }
                else
                {
                    $cookie = $cookie . "; path=/; HttpOnly;secure;SameSite=strict";
                }
        
                header( $cookie );

                NeoLog( "Setting Session ID Cookie: " . $sessionid );
            }
        }
        else
        if ( "auth_logout" == $sp_name )
        {
            header( "Set-Cookie: sid=deleted; path=/; HttpOnly;secure;SameSite=strict; expires=Thu, 01 Jan 1970 00:00:00 GMT" );
     
            NeoLog( "Clearing Session ID Cookie" );
        }
    }

    if ( "TRUE" == getenv( "USE_OAUTH2_TOKEN" ) )
    {
        if ( "auth_oauth2_token" == $sp_name )
        {
            if ( is_a( $ret, 'Results' ) )
            {
                $tuple = $ret->getFirst(); // Retrieve first tuple.

                if ( $tuple && $tuple->access_token )
                {
                    $access_token = $tuple->access_token;

                    echo '{' . '"access_token"' . ':' . '"' . $access_token . '"' . '}';

                    NeoLog( "Returning OAuth Token: " . $access_token );

                    exit( 0 );
                }
            }
        }
    }
} 

CreateResponse

The response from the Web API Bridge is a hierarchical structure encoded in JSON. The outermost object contains the following members that can be used for debugging.

function CreateResponse( $environment, $ret, $microseconds )
{
    $request = $environment["request"];

    $response              = array();
    $response['URL'      ] = $environment["redirect_url"];
    $response['error'    ] = is_array( $ret ) || is_a( $ret, 'Results' ) ? "" : $ret;
    $response['failover' ] = "FALSE";
    $response['hostname' ] = "";
    $response['message'  ] = "";
    $response['status'   ] = is_array( $ret ) || is_a( $ret, 'Results' ) ? "OK" : "ERROR";
    $response['warning'  ] = "";
    $response['target_id'] = array_get( $request, "target_id" );
    $response['submit'   ] = array_get( $request, "submit"    );
    $response['limit'    ] = array_get( $request, "limit"     );
    $response['offset'   ] = array_get( $request, "offset"    );
    $response['microsecs'] = $microseconds;
    $response['results'  ] = is_array( $ret ) || is_a( $ret, 'Results' ) ? $ret : null;

    if ( !array_key_exists( 'accept', $request ) ) $request['accept'] = "";

    if ( is_null( $ret ) )
    {
        $response['error'] = "Could not resolve stored procedure.";
    }

    if ( "TRUE" == getenv( "LOG_ERRORS" ) )
    {
        if ( $response['error'] )
        {
            NeoLogError( "Error: " . $response['error'] );
        }
    }

    return (object) $response;
}

Output Response

function OutputResponse( $sp_name, $response, $request, $use_buffered = false )
{
    NeoLog( "Output Response" );
    NeoLogIn();

    if ( string_has_suffix( $sp_name, "_csv" ) )
    {
        TranslateToCSV ( $response, $request );
    }
    else
    if ( $use_buffered )
    {
        TranslateToJSON( $response );
    }
    else
    {
        TranslateToJSONUnbuffered( $response );
    }

    NeoLogOut();
}

Translate to JSON

Finally works! Refer to: https:stackoverflow.com/questions/15273570/continue-processing-php-after-sending-http-response

Especially, Brian's comment regarding the need for "Content-Encoding" to be set to "none".

function TranslateToJSON( $response )
{
    NeoLog( "Translate to JSON (Buffered)" );

    if ( ob_get_contents() ) ob_end_clean();

    set_time_limit(0);
    ignore_user_abort( TRUE );

    ob_start();
    {
        \JStream::Encode( 0, $response );
        echo "\n";
        $size = ob_get_length();

        header( "Content-Length: $size"          );
        header( "Connection: close"              );
        header( "Content-Encoding: none"         );
        header( "Content-Type: application/json" );

    }
    ob_end_flush();
    ob_flush();
    flush();

    if (session_id()) session_write_close();
}
function TranslateToJSONUnbuffered( $response )
{
    NeoLog( "Translate to JSON (Unbuffered)" );

    set_time_limit(0);
    ignore_user_abort( TRUE );

   {
        header( "Connection: close"              );
        header( "Content-Encoding: none"         );
        header( "Content-Type: application/json" );

        \JStream::Encode( 0, $response );
        echo "\n";
    }
    flush();

    if (session_id()) session_write_close();
}
function TranslateToCSV( $response, $request )
{
    NeoLog( "Translate to CSV" );

    if ( "OK" == $response->status )
    {
        $content  = "";
        $ds       = ("true" == array_get( $request, "double_space" ));
        $numbered = ("true" == array_get( $request, "numbered"     ));
        $map      = GenerateMap( array_get( $request, "csv_map" ) );
        $results  = $response->results;

        header( "Content-Type: application/octet-stream"                    );
        header( "Content-Disposition: attachment;filename=\"download.csv\"" );
        header( "Pragma: public"                                            );
        header( "Cache-Control: must-revalidate, post-check=0, pre-check=0" );
        header( "Connection: close" );

        if ( $map )
        {
            echo \CSV::encode( \CSV::MapValues( $map, $results->toArray() ), $numbered, $ds );
        }
        else
        {
            \CSV::Echo( $results, $numbered, $ds );
        }

        flush();
        exit;
    }
}
function TranslateToCSVOrig( $response, $request )
{
    NeoLog( "Translate to CSV" );

    NeoLog( var_export( $response, true ) );

    if ( "OK" == $response->status )
    {
        $content  = "";
        $ds       = ("true" == array_get( $request, "double_space" ));
        $numbered = ("true" == array_get( $request, "numbered"     ));
        $map      = GenerateMap( array_get( $request, "csv_map" ) );
        $results  = $response->results->toArray();

        if ( $map )
        {
            NeoLog( "Calling CSV::encode with mapped tuples." );

            $content = \CSV::encode( \CSV::MapValues( $map, $results ), $numbered, $ds );
        }
        else
        {
            NeoLog( "Calling CSV::encode with unmapped tuples." );

            $content = \CSV::encode( $results, $numbered, $ds );
        }

        $size = strlen( $content );

        if ( false )
        {
            error_log( "Content-Type: application/octet-stream" );
            error_log( "Content-Length: $size" );
            error_log( "Content-Disposition: attachment;filename=\"download\"" );
        }

        header( "Content-Type: application/octet-stream"                    );
        header( "Content-Length: $size"                                     );
        header( "Content-Disposition: attachment;filename=\"download.csv\"" );
        header( "Pragma: public"                                            );
        header( "Cache-Control: must-revalidate, post-check=0, pre-check=0" );
        header( "Connection: close" );
        echo $content;

        flush();
        exit;
    }
}
function GenerateMap( $base64_encoded_csv_map )
{
    $csv_map =  base64_decode( $base64_encoded_csv_map );

    if ( defined( "VERBOSE" ) && VERBOSE ) error_log( "GenerateMap( \"$csv_map\" )" );

    //
    //  csv_map=Family+Name|family_name,...
    //

    $map = null;

    if ( $csv_map )
    {
        $map  = array();
        $bits = explode( ",", $csv_map );
        
        foreach ( $bits as $mapping )
        {
            $pieces = explode( "|", $mapping );

            if ( 2 == count( $pieces ) )
            {
                $key = urldecode( $pieces[0] );
                $val = urldecode( $pieces[1] );
            
                $map[$key] = $val;
            }

            if ( defined( "VERBOSE" ) && VERBOSE ) error_log( "Mapping( $mapping ) : $key | $val" );
        }
    }
    return $map;
}

Log to Pub Sub

use Google\Cloud\PubSub\PubSubClient;

function LogToPubSub( $environment, $db_info, $db_version, $sp_call, $response, $delta )
{
    if ( "TRUE" == getenv( "USE_GOOGLE_PUB_SUB" ) )
    {
        $topic = GetPubSubTopic();

        $procedure = $sp_call->proc_name . "('" . join( "','", $sp_call->arguments ) . "')";

        if ( !$topic )
        {
            NeoLog( "Not logged to Google PubSub" );
        }
        else
        {
            $now          = date( "c", time() );
            $api_hostname = $environment['server_name' ];
            $endpoint     = $environment['redirect_url'];
            $request      = $environment['request'     ];
            $db           = $db_info->dbname . $db_version;
            $db_hostname  = DB_HOSTNAME;
            $sql64        = base64_encode( $procedure );
            $ip_address   = $_SERVER['SERVER_ADDR'];

            $requesting_url           = array_get(  $request, "wab_requesting_url" );

            $cgi_request_method       = array_get( $_SERVER , "REQUEST_METHOD"       );
            $cgi_request_time         = array_get( $_SERVER , "REQUEST_TIME"         );
            $cgi_http_accept          = array_get( $_SERVER , "HTTP_ACCEPT"          );
            $cgi_http_accept_charset  = array_get( $_SERVER , "HTTP_ACCEPT_CHARSET"  );
            $cgi_http_accept_encoding = array_get( $_SERVER , "HTTP_ACCEPT_ENCODING" );
            $cgi_http_accept_language = array_get( $_SERVER , "HTTP_ACCEPT_LANGUAGE" );
            $cgi_http_referer         = array_get( $_SERVER , "HTTP_REFERER"         );
            $cgi_http_user_agent      = array_get( $_SERVER , "HTTP_USER_AGENT"      );
            $cgi_remote_addr          = array_get( $_SERVER , "HTTP_REMOTE_ADDR"     );
            $cgi_remote_port          = array_get( $_SERVER , "HTTP_REMOTE_PORT"     );
            $cgi_remote_user          = array_get( $_SERVER , "HTTP_REMOTE_USER"     );

            $json  = "{\n";
            $json .= "\"ts\":                       \"$now\",\n";
            $json .= "\"api_hostname\":             \"$api_hostname\",\n";
            $json .= "\"endpoint\":                 \"$endpoint\",\n";
            $json .= "\"type\":                     \"r/w\",\n";
            $json .= "\"status\":                   \"$response->status\",\n";
            $json .= "\"error\":                    \"$response->error\",\n";
            $json .= "\"sql64\":                    \"$sql64\",\n";
            $json .= "\"response_time_ms\":         \"$response->microsecs\",\n";
            $json .= "\"db\":                       \"$db\",\n";
            $json .= "\"db_version\":               \"$db_version\",\n";
            $json .= "\"db_hostname\":              \"$db_hostname\",\n";
            $json .= "\"ip_address\":               \"$ip_address\",\n";
            $json .= "\"requesting_url\":           \"$requesting_url\",\n";
            $json .= "\"cgi_request_method\":       \"$cgi_request_method\",\n";
            $json .= "\"cgi_request_time\":         \"$cgi_request_time\",\n";
            $json .= "\"cgi_http_accept\":          \"$cgi_http_accept\",\n";
            $json .= "\"cgi_http_accept_charset\":  \"$cgi_http_accept_charset\",\n";
            $json .= "\"cgi_http_accept_encoding\": \"$cgi_http_accept_encoding\",\n";
            $json .= "\"cgi_http_accept_language\": \"$cgi_http_accept_language\",\n";
            $json .= "\"cgi_http_referer\":         \"$cgi_http_referer\",\n";
            $json .= "\"cgi_http_user_agent\":      \"$cgi_http_user_agent\",\n";
            $json .= "\"cgi_remote_addr\":          \"$cgi_remote_addr\",\n";
            $json .= "\"cgi_remote_port\":          \"$cgi_remote_port\",\n";
            $json .= "\"cgi_remote_user\":          \"$cgi_remote_user\"\n";
            $json .= "}\n";

            try
            {
                $topic->publish( ['data' => $json] );

                NeoLog( "Logged to Google PubSub" );
            }
            catch ( Exception $ex )
            {
                NeoLog( $ex );
            }
        }
    }
}
function GetPubSubTopic()
{
    $topic = null;

    NeoLogIn();

    if ( !getenv( "GOOGLE_APPLICATION_CREDENTIALS" ) )
    {
        NeoLog( "!!! WARNING !!! GOOGLE_APPLICATION_CREDENTIALS not defined in Apache configuration, but USE_GOOGLE_PUB_SUB is!" );
    }
    else
    if ( !getenv( "GOOGLE_PUB_SUB_PROJECT" ) )
    {
        NeoLog( "!!! WARNING !!! GOOGLE_PUB_SUB_PROJECT not defined in Apache configuration, but USE_GOOGLE_PUB_SUB is!" );
    }
    else
    if ( !getenv( "GOOGLE_PUB_SUB_TOPIC" ) )
    {
        NeoLog( "!!! WARNING !!! GOOGLE_PUB_SUB_TOPIC not defined in Apache configuration, but USE_GOOGLE_PUB_SUB is!" );
    }
    else
    {
        $pubsub_project = getenv( "GOOGLE_PUB_SUB_PROJECT" );
        $pubsub_topic   = getenv( "GOOGLE_PUB_SUB_TOPIC"   );

        try
        {
            $pubsub = new PubSubClient( ['projectId' => $pubsub_project] );
            $topic  = $pubsub->topic( $pubsub_topic );
        }
        catch( Exception $e )
        {
            NeoLog( "!!! WARNING !!! Could not use GOOGLE credentials: " . getEnv( "GOOGLE_APPLICATION_CREDENTIALS" ) );
        }
    }

    NeoLogOut();

    return $topic;
}

A -- Strings

<?php
function array_get( $array, $key )
{
    return array_key_exists( $key, $array ) ? $array[$key] : "";
}
function string_contains( $haystack, $needle )
{
    return (0 == strlen($needle)) || (false !== strpos( $haystack, $needle ));
}
function string_has_prefix( $haystack, $needle )
{
    return (0 == strlen($needle)) || (0 === strpos( $haystack, $needle ));
}
function string_has_suffix( $haystack, $needle )
{
    $expected = strlen( $haystack ) - strlen( $needle );

    return (0 == strlen($needle)) || ($expected === strrpos( $haystack, $needle ));
}
function test()
{
    if (    string_contains( "www.example.com", ""                ) ) echo "Passed #1" . "\n";
    if (    string_contains( "www.example.com", "www."            ) ) echo "Passed #2" . "\n";
    if (    string_contains( "www.example.com",    ".example."    ) ) echo "Passed #3" . "\n";
    if (    string_contains( "www.example.com",            ".com" ) ) echo "Passed #4" . "\n";
    if (   !string_contains( "www.example.com", "wwl"             ) ) echo "Passed #5" . "\n";
    if (   !string_contains( "www.example.com",    ".exanple"     ) ) echo "Passed #6" . "\n";
    if (   !string_contains( "www.example.com",            ".con" ) ) echo "Passed #7" . "\n";

    if (  string_has_prefix( "www.example.com", ""                ) ) echo "Passed #8" . "\n";
    if (  string_has_prefix( "www.example.com", "www."            ) ) echo "Passed #9" . "\n";
    if (  string_has_prefix( "www.example.com", "www.example."    ) ) echo "Passed #A" . "\n";
    if (  string_has_prefix( "www.example.com", "www.example.com" ) ) echo "Passed #B" . "\n";
    if ( !string_has_prefix( "www.example.com", "wwl"             ) ) echo "Passed #C" . "\n";
    if ( !string_has_prefix( "www.example.com", "www.exanple"     ) ) echo "Passed #D" . "\n";
    if ( !string_has_prefix( "www.example.com", "www.example.con" ) ) echo "Passed #E" . "\n";

    if (  string_has_suffix( "www.example.com", ""                ) ) echo "Passed #F" . "\n";
    if (  string_has_suffix( "www.example.com",            ".com" ) ) echo "Passed #G" . "\n";
    if (  string_has_suffix( "www.example.com",    ".example.com" ) ) echo "Passed #H" . "\n";
    if (  string_has_suffix( "www.example.com", "www.example.com" ) ) echo "Passed #I" . "\n";
    if ( !string_has_suffix( "www.example.com",            ".con" ) ) echo "Passed #J" . "\n";
    if ( !string_has_suffix( "www.example.com",    ".example.con" ) ) echo "Passed #K" . "\n";
    if ( !string_has_suffix( "www.example.com", "www.example.con" ) ) echo "Passed #L" . "\n";
}
<?php

class CSV
{
    static $newline = "\r\n";


    static function PlainText()
    {
        header( "Content-Type: text/plain" );
    }

    static function InitiateDownload( $filename="download.csv" )
    {
        header( "Content-Type: application/octet-stream" );
        header( "Content-Disposition: attachment; filename=\"$filename\"" );
        header("Pragma: public");
        header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
    }

    static function encode( $results, $numbered = true, $double_spaced = false )
    {
        $ret = "";

        if ( is_array( $results ) && (0 < count( $results ) ) )
        {
            $ret .= CSV::Heading( $results, $numbered );
            $ret .= CSV::Rows( $results, $numbered, $double_spaced );
        }
        
        return $ret;
    }

    static function Echo( $results, $numbered = true, $double_spaced = false )
    {
        if ( is_a( $results, 'Results' ) )
        {
            $it = $results->iterator();

            if ( $it->hasNext() )
            {
                NeoLog( "CSV::Echo" );

                CSV::EchoHeading( $it, $numbered );
                CSV::EchoRows   ( $it, $numbered, $double_spaced );
            }
        }
    }

    static function EchoHeading( $it, $numbered )
    {
        $heading = "";
    
        if ( $it->hasFirst() )
        {
            $tuple = $it->getFirst();
            $sep   = "";
        
            foreach ( $tuple as $key => $value )
            {
                $heading .= $sep;
                $heading .= $key;
                $sep = ",";
            }

            unset( $tuple ); $tuple = null;
        }
        if ( $numbered ) $heading .= ",#";

        echo $heading .= self::$newline;
    }
    
    static function Heading( $it, $numbered )
    {
        $heading = "";
    
        foreach ( $results as $tuple )
        {
            $sep = "";
        
            foreach ( $tuple as $key => $value )
            {
                $heading .= $sep;
                $heading .= $key;
                $sep = ",";
            }
            break;
        }
        if ( $numbered ) $heading .= ",#";

        return $heading .= self::$newline;
    }

    static function EchoRows( $it, $numbered, $double_spaced = false )
    {
        $nr  = 0;
    
        while ( $it->hasNext() )
        {
            $tuple = $it->next();
            $row   = "";
            $sep   = "";

            $nr++;
        
            if ( $tuple )
            {
                foreach ( $tuple as $key => $value )
                {
                    $row .= $sep;

                    $value = html_entity_decode( $value, ENT_QUOTES );

                    if ( string_contains( $value, "," ) )
                    {
                        $row .= "\"$value\"";
                    }
                    else
                    {
                        $row .= "$value";
                    }
                    $sep = ",";
                }
                if ( $numbered ) $row .= ",$nr";

                if ( $double_spaced ) $row .= self::$newline;
            }

            $row .= self::$newline;

            echo $row;

            unset( $tuple ); $tuple = null;

            flush();
        }
    }

    static function Rows( $results, $numbered, $double_spaced = false )
    {
        $nr   = 0;
        $rows = "";
    
        foreach ( $results as $tuple )
        {
            $nr++;
            $sep = "";
        
            foreach ( $tuple as $key => $value )
            {
                $rows .= $sep;

                $value = html_entity_decode( $value, ENT_QUOTES );

                if ( string_contains( $value, "," ) )
                {
                    $rows .= "\"$value\"";
                }
                else
                {
                    $rows .= "$value";
                }
                $sep = ",";
            }
            if ( $numbered ) $rows .= ",$nr";

            $rows .= self::$newline;

            if ( $double_spaced ) $rows .= self::$newline;
        }

        return $rows;
    }
    
    static function MapValues( $map, $tuples )
    {
        $mapped_tuples = array();
    
        foreach ( $tuples as $obj )
        {
            $tuple  = (array) $obj;
            $mapped = array();
            
            foreach ( $map as $label => $key )
            {
                if ( array_key_exists( $key, $tuple ) )
                {
                    $mapped[$label] = $tuple[$key];
                }
                else
                {
                    error_log( "Could not find $key in tuple." );
                }
            }
            
            $mapped_tuples[] = $mapped;
        }
        
        return $mapped_tuples;
    }
}

Experimental

The experimental function is used to determine if experimental code paths should be followed for the current domain.

<?php
//  Copyright (c) 2009, 2020 Daniel Robert Bradley. All rights reserved.
//  This software is distributed under the terms of the GNU Lesser General Public License version 2.1
?>
<?php

function Experimental()
{
    return
        ("TRUE" == getenv( "USE_EXPERIMENTAL"))
        ||
        (defined( "EXPERIMENTAL" ) && array_key_exists( $_SERVER["SERVER_NAME"], EXPERIMENTAL ) && EXPERIMENTAL[$_SERVER["SERVER_NAME"]]);
}

Input

<?php
//  Copyright (c) 2009, 2010 Daniel Robert Bradley. All rights reserved.
//  This software is distributed under the terms of the GNU Lesser General Public License version 2.1
?>
<?php

class Output
{
    function println()
    {}

    function indent()
    {}

    function outdent()
    {}
}

function DBi_escape( $string )
{
    return $string;

    $db = DBi_anon();
    
    if ( $db->connect( new NullPrinter() ) )
    {
        return $db->escape( $string );
    }
}

class Input
{
    static function FilterInput( $request, $debug )
    {
        $debug    = new Output();
        $filtered = array();

        $debug->println( "<!-- FilterInput() start -->" );
        $debug->indent();
        {
            
            $debug->println( "<!-- REQUEST -->" );
            $debug->indent();
            {
                foreach ( $_REQUEST as $key => $val )
                {
                    $filtered_key = Input::Filter( $key );
                    $filtered_val = Input::Filter( $val );

                    $filtered[$filtered_key] = $filtered_val;

                    if ( is_array( $filtered_val ) )
                    {
                        $debug->println( "<!-- \"$filtered_key\" | Array -->" );
                    }
                    else
                    {
                        $debug->println( "<!-- \"$filtered_key\" | \"$filtered_val\" -->" );
                    }
                }
            }
            $debug->outdent();

            $debug->println( "<!-- COOKIE -->" );
            $debug->indent();
            {
                foreach ( $_COOKIE as $key => $val )
                {
                    if ( ! array_key_exists( $key, $filtered ) )
                    {
                        $filtered_key = Input::Filter( $key );
                        $filtered_val = Input::Filter( $val );

                        $filtered[$filtered_key] = $filtered_val;
                        $debug->println( "<!-- \"$filtered_key\" | \"$filtered_val\" -->" );
                    }
                }
            }
            $debug->outdent();
        }
        $debug->outdent();
        $debug->println( "<!-- FilterInput() end -->" );

        return $filtered;
    }

    static function Filter( $value )
    {
        if ( is_array( $value ) )
        {
            $ret = array();
            
            foreach ( $value as $key => $val )
            {
                $filtered_key = Input::Filter( $key );
                $filtered_val = Input::Filter( $val );
            
                $ret[$filtered_key] = $filtered_val;
            }
            
            return $ret;
        }
        else
        if ( is_string( $value ) )
        {
            //$value = Input::unidecode( $value );
            $value = utf8_decode( $value );
            $value = htmlspecialchars( $value, ENT_QUOTES, 'UTF-8', false );
            $value = addslashes( $value );
            $value = DBi_escape( $value );

            $value = str_replace(   "\n",  "<br>", $value );
            $value = str_replace( "\\\\", "\", $value );
            $value = str_replace( "\x09",     " ", $value );

            return $value;
        }
        else
        if ( is_null( $value ) )
        {
            return "";
        }
        else
        {
            error_log( "Input::Filter( $value ): unexpected value!" );
        }
    }

    static function unidecode( $value )
    {
        $str = "";
        $n   = strlen( $value );
        $i   = 0;
        
        while ( $i < $n )
        {
            $ch  = substr( $value, $i, 1 );
            $val = ord( $ch );

            if ( ($val == (0xFC | $val)) && ($i+5 < $n) )       // 6 byte unicode
            {
                $str .= Input::utf2html( substr( $value, $i, 6 ) );
                $i   += 6;
            }
            else
            if ( ($val == (0xF8 | $val)) && ($i+4 < $n) )       // 5 byte unicode
            {
                $str .= Input::utf2html( substr( $value, $i, 5 ) );
                $i   += 5;
            }
            else
            if ( ($val == (0xF0 | $val)) && ($i+3 < $n) )       // 4 byte unicode
            {
                $str .= Input::utf2html( substr( $value, $i, 4 ) );
                $i   += 4;
            }
            else
            if ( ($val == (0xE0 | $val)) && ($i+2 < $n) )       // 3 byte unicode
            {
                $str .= Input::utf2html( substr( $value, $i, 3 ) );
                $i   += 3;
            }
            else
            if ( ($val == (0xC0 | $val)) && ($i+1 < $n) )   // 2 byte unicode
            {
                $str .= Input::utf2html( substr( $value, $i, 2 ) );
                $i   += 2;
            }
            else
            if ( $val == (0x80 | $val) )        // extra byte
            {
                error_log( "Warning detected invalid unicode" );
                $str .= '?';
                $i++;
            }
            else                                // ascii character
            {
                $str .= $ch;
                $i++;
            }
        }
        return $str;
    }

    static function utf2html( $string )
    {
        $array  = Input::utf8_to_unicode( $string );
        $string = Input::unicode_to_entities( $array );
        
        return $string;
    }

    static function utf8_to_unicode( $str )
    {
        $unicode = array();
        $values = array();
        $lookingFor = 1;
        
        for ($i = 0; $i < strlen( $str ); $i++ ) {

            $thisValue = ord( $str[ $i ] );
            
            if ( $thisValue < 128 ) $unicode[] = $thisValue;
            else {
            
                if ( count( $values ) == 0 ) $lookingFor = ( $thisValue < 224 ) ? 2 : 3;
                
                $values[] = $thisValue;
                
                if ( count( $values ) == $lookingFor ) {
            
                    $number = ( $lookingFor == 3 ) ?
                        ( ( $values[0] % 16 ) * 4096 ) + ( ( $values[1] % 64 ) * 64 ) + ( $values[2] % 64 ):
                        ( ( $values[0] % 32 ) * 64 ) + ( $values[1] % 64 );
                        
                    $unicode[] = $number;
                    $values = array();
                    $lookingFor = 1;
            
                } // if
            
            } // if
            
        } // for

        return $unicode;
    
    }

    static function unicode_to_entities( $unicode )
    {
        $entities = '';
        foreach( $unicode as $value ) $entities .= '&#' . $value . ';';
        return $entities;
    }
}
<?php
//  Copyright (c) 2014 Daniel Robert Bradley. All rights reserved.
//  This software is distributed under the terms of the GNU Lesser General Public License version 2.1
?>
<?php

class JSON4
{
    static function EncodeResults( $indent, $results )
    {
        $json = "";
    
        $json .= "{";
        
        if ( is_array( $results ) && (0 < count( $results ) ) )
        {
            $json .= '"results":';
            $json .= "[";
            
            $sep = "";
            
            foreach ( $results as $tuple )
            {
                $json .= $sep;
                $json .= self::EncodeTuple( $indent + 1, $tuple );
                $sep = ",";
            }
            
            $json .= "]";
        }
        
        $json .= "}";

        return $json;
    }

    static function EncodeTuple( $indent, $tuple )
    {
        $json = "\n" . str_repeat( " ", $indent * 4 );
        $json .= "{";
        $sep = "";
    
        foreach ( $tuple as $key => $value )
        {
            $json .= $sep;

            $json .= self::EncodeStringValue( $indent + 1, $key, $value );

            $sep = ",";
        }

        $json .= "\n" . str_repeat( " ", $indent * 4 ) . "}";

        return $json;
    }

    static function Encode( $indent, $something )
    {
        $json = "" . str_repeat( " ", $indent * 4 );

        if ( is_array( $something ) )
        {
            $json .= self::EncodeArray( $indent + 1, $something );
        }
        else
        {
            $json .= self::EncodeObject( $indent + 1, $something );
        }

        return $json;
    }

    static function EncodeArray( $indent, $array )
    {
        $json = "\n" . str_repeat( " ", $indent * 4 );
        $json .= "[";
        $sep = "";
        
        if ( self::is_assoc( $array ) )
        {
            foreach ( $array as $string => $value )
            {
                $json .= $sep . "{";
                
                $json .= self::EncodeStringValue( $indent + 1, $string, $value );
                
                $json .= "}";

                $sep = ",";
            }
        }
        else
        {
            foreach ( $array as $value )
            {
                $json .= $sep;
                
                $json .= self::EncodeValue( $indent + 1, $value );
                
                $sep = ",";
            }
        }
        $json .= "\n" . str_repeat( " ", $indent * 4 ) . "]";

        return $json;
    }

    static function EncodeObject( $indent, $object )
    {
        $json = "\n" . str_repeat( " ", $indent * 4 );
        $json .= "{";
        $sep = "";

        foreach ( $object as $member => $value )
        {
            $json .= $sep;
            
            $json .= self::EncodeStringValue( $indent + 1, $member, $value );

            $sep = ",";
        }
        $json .= "\n" . str_repeat( " ", $indent * 4 ) . "}";

        return $json;
    }

    static function EncodeStringValue( $indent, $string, $value )
    {
        $json = "\n" . str_repeat( " ", $indent * 4 );
        $json .= self::EncodeString( $indent + 1, $string );
        $json .= ":";
        $json .= self::EncodeValue( $indent + 1, $value );

        return $json;
    }

    static function EncodeString( $indent, $string )
    {
        $json = "";
        $escaped = str_replace( "\\", "\\\\", $string );

        $json .= "\"$escaped\"";

        return $json;
    }

    static function EncodeValue( $indent, $value )
    {
        $json = "";
        if ( is_array( $value ) )
        {
            $json .= self::EncodeArray( $indent, $value );
        }
        else
        if ( is_string( $value ) )
        {
            $json .= self::EncodeString( $indent, $value );
        }
        else
        if ( is_numeric( $value ) )
        {
            $json .= self::EncodeNumber( $indent, $value );
        }
        else
        if ( is_null( $value ) )
        {
            $json .= "null";
        }
        else
        if ( true === $value )
        {
            $json .= "true";
        }
        else
        if ( false === $value )
        {
            $json .= "false";
        }
        else
        {
            $json .= self::EncodeObject( $indent, $value );
        }

        return $json;
    }

    static function EncodeNumber( $indent, $number )
    {
        $json = "";
        $json .= $number;

        return $json;
    }

    static function is_assoc( $a )
    {
        $assoc = true;
    
        $keys = array_keys( $a );
        foreach ( $keys as $key )
        {
            if ( is_numeric( $key ) && (0 == $key) ) $assoc = false;
            break;
        }
        return $assoc;
    }

    static function is_assocx( $a )
    {
        $b = array_keys($a);

        return ($a != array_keys($b));
    }
}
<?php
//  Copyright (c) 2015 Daniel Robert Bradley. All rights reserved.
//  This software is distributed under the terms of the GNU Lesser General Public License version 2.1
?>
<?php

class JStream
{
    static function Encode( $indent, $something )
    {
        if ( is_array( $something ) )
        {
            self::EncodeArray( $indent, $something );
        }
        else
        {
            self::EncodeObject( $indent, $something );
        }
    }

    static function EncodeResults( $indent, $results )
    {
        echo "{";
        
        if ( is_array( $results ) && (0 < count( $results ) ) )
        {
            echo '"results":';
            echo "[";
            
            $sep = "";
            
            foreach ( $results as $tuple )
            {
                echo $sep;
                self::EncodeTuple( $index + 1, $tuple );
                $sep = ",";
            }
            
            echo "]";
        }
        
        echo "}";
    }

    static function EncodeTuple( $indent, $tuple )
    {
        echo "\n" . str_repeat( " ", $indent * 4 ) . "{";
        $sep = "";
    
        foreach ( $tuple as $key => $value )
        {
            echo $sep;

            self::EncodeStringValue( $indent + 1, $key, $value );

            $sep = ",";
        }

        echo "\n" . str_repeat( " ", $indent * 4 ) . "}";
    }

    static function EncodeArray( $indent, $array )
    {
        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "[";
        $sep = "";
        
        if ( self::is_assoc( $array ) )
        {
            foreach ( $array as $string => $value )
            {
                echo $sep . "{";
                
                self::EncodeStringValue( $indent + 1, $string, $value );
                
                echo "}";

                $sep = ",";
            }
        }
        else
        {
            foreach ( $array as $value )
            {
                echo $sep;
                
                self::EncodeValue( $indent + 1, $value );
                
                $sep = ",";
            }
        }

        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "]";
    }

    static function EncodeObject( $indent, $object )
    {
        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "{";
        $sep = "";

        foreach ( $object as $member => $value )
        {
            echo $sep;
            
            self::EncodeStringValue( $indent + 1, $member, $value );

            $sep = ",";
        }
        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "}";
    }

    static function EncodeStringValue( $indent, $string, $value )
    {
        echo "\n" . str_repeat( " ", $indent * 4 );

        if ( is_string( $value ) )
        {
            $headers = apache_request_headers();

            if ( array_key_exists( 'Accept', $headers ) )
            {
                switch( $headers['Accept'] )
                {
                case "application/json":
                    $value = html_entity_decode( $value, ENT_QUOTES );
                    $value = str_replace( "<br>", "\n", $value );
                    break;
                }
            }
        }

        if ( string_has_prefix( $string, "__json_" ) )
        {
            self::EncodeString( $indent, substr( $string, 7 ) );
            echo ":";
            echo json_encode( json_decode( $value ) );
        }
        else
        {
            self::EncodeString( $indent, $string );
            echo ":";
            self::EncodeValue( $indent, $value );
        }
    }

    static function EncodeString( $indent, $string )
    {
        $escaped = json_encode( $string ); // str_replace( "\\", "\\\\", $string );

        if ( false === $escaped )
        {
            error_log( "ERROR1: " . var_export( $string,  true ) );
            $escaped = json_encode( htmlentities( $string ) );
        }

        if ( false === $escaped )
        {
            error_log( "ERROR2: " . var_export( $string,  true ) );
            $escaped = json_encode( "" );
        }

        echo $escaped;
    }

    static function EncodeValue( $indent, $value )
    {
        if ( true === $value )
        {
            echo "true";
        }
        else
        if ( false === $value )
        {
            echo "false";
        }
        else
        if ( is_array( $value ) )
        {
            self::EncodeArray( $indent, $value );
        }
        else
        if ( is_string( $value ) )
        {
            self::EncodeString( $indent, $value );
        }
        else
        if ( is_numeric( $value ) )
        {
            self::EncodeNumber( $indent, $value );
        }
        else
        if ( is_null( $value ) )
        {
            echo "null";
        }
        else
        if ( is_a( $value, 'Results' ) )
        {
            if ( $value->isProcessed() )
            {
                //  This should never be executed because the 'Results' object
                //  is only every "processed" by the TranslateToCSV code path
                //  which is orthogonal to this one...
                //  I will remove this when I remove the "map" code path
                //  from TranslateToCSV.

                NeoLog( "Abort!!! Invalid code path." );
                //$array = $value->toArray();
                //self::EncodeArray( $indent, $array );
            }
            else
            {
                self::EncodeResultArray( $indent, $value );
            }
        }
        else
        {
            self::EncodeObject( $indent, $value );
        }
    }

    static function EncodeResultArray( $indent, $result_array )
    {
        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "[";
        $sep = "";
        
        $it = $result_array->iterator();

        while ( $it->hasNext() )
        {
            $value = $it->next();

            echo $sep;
            \JStream::EncodeValue( $indent + 1, $value ); 
            $sep = ",";

            unset( $value ); $value = null;
        }

        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "]";
    }

    static function EncodeNumber( $indent, $number )
    {
        echo json_encode( $number );
    }

    static function is_assoc( $a )
    {
        $assoc = true;
    
        $keys = array_keys( $a );
        foreach ( $keys as $key )
        {
            if ( is_numeric( $key ) && (0 == $key) ) $assoc = false;
            break;
        }
        return $assoc;
    }

    static function is_assocx( $a )
    {
        $b = array_keys($a);

        return ($a != array_keys($b));
    }
}

Log

<?php

class Neo
{
    static $neolog_indent;
    static $neolog_connection_id;
    static $neolog_log_level;

    static function Init()
    {
        $strong;
        self::$neolog_connection_id = bin2hex( openssl_random_pseudo_bytes( 2, $strong ) );

        self::$neolog_log_level = intval( getenv( "SHOW_LOG_TO_LEVEL" ) );

        if ( ! is_numeric( self::$neolog_log_level ) )
        {
            self::$neolog_log_level = 100;
        }
    }

    static function In()
    {
        self::$neolog_indent++;
    }

    static function Out()
    {
        if ( 0 < self::$neolog_indent ) self::$neolog_indent--;
    }

    static function Log( $text )
    {
        $indent = intval( self::$neolog_indent    );
        $level  = intval( self::$neolog_log_level );

        if ( $indent <= $level )
        {
            self::LogError( $text );
        }
    }

    static function LogError( $text )
    {
        $now = isset( $_SERVER ) ? "" : date( DATE_ISO8601 );
    
        $stars = str_repeat( "+", self::$neolog_indent );

        error_log( sprintf( "[%s] %s%-8s %s", self::$neolog_connection_id, $now, $stars, $text ) );
    }
}

Neo::Init();

function NeoLog( $text )
{
    Neo::Log( $text );
}

function NeoLogError( $text )
{
    Neo::LogError( $text );
}

function NeoLogIn()
{
    Neo::In();
}

function NeoLogOut()
{
    Neo::Out();
}

MySQL

<?php

function MySQLCreate()
{
    //NeoLog( 3, "DB_HOSTNAME: " . DB_HOSTNAME );
    //NeoLog( 3, "DB_USERNAME: " . DB_USERNAME );
    //NeoLog( 3, "DB_PASSWORD: " . DB_PASSWORD );
    //NeoLog( 3, "SSL_BASE:    " . SSL_BASE    );

    $m = mysqli_init();

    if ( !$m )
    {
        NeoLog( "Could not initialise 'mysqli'" );
        exit;
    }

    ConfigureSSL( $m, SSL_BASE, DB_HOSTNAME );

    $connection = @$m->real_connect( DB_HOSTNAME, DB_USERNAME, DB_PASSWORD, null, null, null, MYSQLI_CLIENT_SSL_DONT_VERIFY_SERVER_CERT );

    if ( !$connection )
    {
        if ( "No such file or directory" == $m->error )
        {
            NeoLog( "Aborting: could not connect to " . DB_HOSTNAME . " using " . DB_USERNAME . ":" . DB_PASSWORD );
            exit;
        }
        else
        {
            NeoLog( "Aborting: unexpected error: " . $m->error );
            exit;
        }
    }

    return $m; // Same as $m.
}

function MySQLClose( $m )
{
    mysqli_close( $m );
}

function MySQLInfo( $mysql, $sql_query )
{
    $tuples   = array();
    $resource = mysqli_query( $mysql, $sql_query );

    if ( !$resource )
    {
        NeoLog( $mysql->error );
        exit;
    }
    else
    {
        while ( $row = mysqli_fetch_array( $resource, MYSQLI_ASSOC ) )
        {
            $tuples[] = $row;
        }
    }
    return $tuples;
}

function MySQLFunction( $db, $function )
{
    $ret      = null;
    $sql      = "SELECT $function";
    $m        = MySQLCreate();

    if ( ! mysqli_select_db( $m, $db ) )
    {
        NeoLog( "Aborting, could not select database! " . $db );
        exit;
    }
    else
    {
        $resource = mysqli_query( $m, $sql );

        if ( True === $resource )
        {
            $ret = True;
        }
        else
        if( False === $resource )
        {
            $ret = False;
        }
        else
        if ( $resource )
        {
            $row = mysqli_fetch_array( $resource, MYSQLI_NUM );
            $ret = array_key_exists( 0, $row ) ? $row[0] : NULL;
            mysqli_free_result( $resource );
        }
        else
        {
            NeoLog( "Aborting, " . $m->error );
            exit;
        }
        mysqli_next_result( $m );
    }

    MySQLClose( $m );

    return $ret;
}

function MySQLProcedure( $db, $sp_call, &$procedure = "" )
{
    $ret = False;

    if ( !is_object( $sp_call ) )
    {
        debug_backtrace();
    }

    $proc_name = $sp_call->proc_name;
    $arguments = $sp_call->arguments;

    $m = MySQLCreate();

    if ( ! mysqli_select_db( $m, $db ) )
    {
        NeoLog( "Aborting, could not select database! " . $db );
        MySQLClose( $m );
        exit;
    }
    else
    {
		$count = 0;
        $filtered = array();
        foreach( $arguments as $argument )
        {
            if ( is_null( $argument ) )
            {
                $filtered[] = "NULL";
            }
            else
            {
                $filtered[] = "'" . mysqli_real_escape_string( $m, $argument ) . "'";
            }
        }

        $procedure = $proc_name . "(" . join( ",", $filtered ) . ")";

        $sql_query = "CALL " . $procedure;

        if ( "wab_test" == $proc_name )
        {
            NeoLog( "Test: " . $sql_query );
        }

        try
        {
            $resource  = mysqli_query( $m, $sql_query );
        }
        catch ( Exception $e )
        {
            //  MySQL thrown errors seem to be now throwing exceptions...
            //  Is this a MariaDB thing; or updated phpmysqli...
            //
            $resource = False;
            $ret = $e->getMessage();
        }

        if ( True === $resource )
        {
            $ret = array();
        }
        else
        if( False === $resource )
        {
            $ret = $m->error;
        }
        else
        if ( $resource )
        {
            $ret = array();

            while ( $row = mysqli_fetch_array( $resource, MYSQLI_ASSOC ) )
            {
                $ret[] = (object) $row;
                $count++;
            }

            mysqli_free_result( $resource );
        }
        else
        {
            NeoLog( "Aborting, " . $m->error );
            MySQLClose( $m );
            exit;
        }
        mysqli_next_result( $m );

		if ( "TRUE" == getenv( "LOG_STORED_PROCEDURE_CALL" ) )
		{
			NeoLogError( "Called: " . $sql_query . ": returned " . $count . " rows" );
		}
    }

    MySQLClose( $m );

    return $ret;
}

class ResultIterator
{
    protected $m;
    protected $result;
    protected $row;

    function __construct( $anM, $aResult )
    {
        $this->m      = $anM;
        $this->result = $aResult;
        $this->row    = mysqli_fetch_array( $this->result, MYSQLI_ASSOC );
        $this->first  = $this->row;
    }

    function __destruct()
    {
        mysqli_free_result( $this->result );
        mysqli_next_result( $this->m      );
        MySQLClose        ( $this->m      );
    }

    function hasFirst()
    {
        return $this->first ? true : false;
    }

    function getFirst()
    {
        return (object) $this->first;
    }

    function hasNext()
    {
        return $this->row ? true : false;
    }

    function next()
    {
        $ret       = $this->row;
        $this->row = null;
        $this->row = mysqli_fetch_array( $this->result, MYSQLI_ASSOC );

        return (object) $ret;
    }
}

class Results
{
	public    $sqlQuery;
    protected $it;
    protected $array;
	protected $result;

    function __construct( $sql_query, $anM, $aResult )
    {
		$this->sqlQuery = $sql_query;
        $this->it       = new ResultIterator( $anM, $aResult );
        $this->array    = null;
        $this->result   = $aResult;
    }

    function hasFirst()
    {
        return $this->it->hasFirst();
    }

    function getFirst()
    {
        return $this->it->getFirst();
    }


    //  Called by OutputResponse.TranslateToCSV
    function toArray()
    {
        if ( is_null( $this->array ) )
        {
            $this->array = array();

            while ( $this->it->hasNext() )
            {
                $this->array[] = (object) $this->it->next();
            }
        }

        return $this->array;
    }

    function toStringX()
    {
        return var_export( $this->array, true );
    }

    function isProcessed()
    {
        return !is_null( $this->array );
    }

    function encodeArrayX( $indent )
    {
        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "[";
        $sep = "";
        
        while ( $this->it->hasNext() )
        {
            $value = (object) $this->it->next();

            echo $sep;
            \JStream::EncodeValue( $indent + 1, $value ); 
            $sep = ",";
        }

        echo "\n" . str_repeat( " ", $indent * 4 );
        echo "]";
    }

    function iterator()
    {
        return $this->it;
    }
    
    function numRows()
    {
		return mysqli_num_rows( $this->result );
    }
}

function MySQLProcedureResults( $db, $sp_call, &$procedure = "" )
{
    $ret = False;

    if ( !is_object( $sp_call ) )
    {
        debug_backtrace();
    }

    $proc_name = $sp_call->proc_name;
    $arguments = $sp_call->arguments;

    $m = MySQLCreate();

    if ( ! mysqli_select_db( $m, $db ) )
    {
        NeoLog( "Aborting, could not select database! " . $db );
        MySQLClose( $m );
        exit;
    }
    else
    {
        $filtered = array();
        foreach( $arguments as $argument )
        {
            if ( is_null( $argument ) )
            {
                $filtered[] = "NULL";
            }
            else
            {
                $filtered[] = "'" . mysqli_real_escape_string( $m, $argument ) . "'";
            }
        }

        $procedure = $proc_name . "(" . join( ",", $filtered ) . ")";

        $sql_query = "CALL " . $procedure;

        if ( "wab_test" == $proc_name )
        {
            NeoLog( "Test: " . $sql_query );
        }

        try
        {
            $resource  = mysqli_query( $m, $sql_query, MYSQLI_USE_RESULT );
        }
        catch ( Exception $e )
        {
            //  MySQL thrown errors seem to be now throwing exceptions...
            //  Is this a MariaDB thing; or updated phpmysqli...
            //
            $resource = False;
            $ret = $e->getMessage();
        }

        NeoLog( "MySQL - MYSQLI_USE_RESULT" );

        if ( True === $resource )
        {
            $ret = array();
        }
        else
        if( False === $resource )
        {
            $ret = $m->error;
        }
        else
        if ( $resource )
        {
            if ( "auth_login" == strtolower( $proc_name ) )
            {
                $ret = new Results( "CALL auth_login( [hidden] )", $m, $resource );
            }
            else
            {
                $ret = new Results( $sql_query, $m, $resource );
            }
        }
        else
        {
            NeoLog( "Aborting, " . $m->error );
            MySQLClose( $m );
            exit;
        }
    }

    if ( !is_a( $ret, 'Results' ) )
    {
        mysqli_next_result( $m );
        MySQLClose( $m );
    }

    return $ret;
}

SSL

<?php

function ConfigureSSL( $mysqli, $ssl_base, $host )
{
    if ( file_exists( "$ssl_base/$host/client-key.pem" ) )
    {
        mysqli_ssl_set
        (
            $mysqli,
            "$ssl_base/$host/client-key.pem",
            "$ssl_base/$host/client-cert.pem",
            "$ssl_base/$host/ca-cert.pem",
            NULL,
            NULL
        );
    }
    else
    if ( file_exists( "$ssl_base/$host/server-ca.pem" ) )
    {
        NeoLog( "Warning: not using x509 authenication as cannot find client key/cert." );

        mysqli_ssl_set
        (
            $mysqli,
            NULL,
            NULL,
            "$ssl_base/$host/server-ca.pem",
            NULL,
            NULL
        );
    }
    else
    if( "localhost" != $host )
    {
        NeoLog( "Could not locate SSL files: " . "$ssl_base/$host/client-key.pem" );
    }
}

Test

DROP   PROCEDURE Wab_Test;
DELIMITER //
CREATE PROCEDURE Wab_Test
(
    $Sid     TEXT,
    $apikey  CHAR(64),
    $date    DATE,
    $text    TEXT,
    $number  INT
)
SQL SECURITY DEFINER
COMMENT 'EXPORT'
BEGIN

    SELECT
        $Sid    AS Sid,
        $apikey AS apikey,
        $date   AS date,
        $text   AS text,
        $number AS number;

END
//
DELIMITER ;
DROP   PROCEDURE Raw_Wab_Test;
DELIMITER //
CREATE PROCEDURE Raw_Wab_Test
(
    $Sid     TEXT,
    $apikey  CHAR(64),
    $date    DATE,
    $text    TEXT,
    $number  INT
)
SQL SECURITY DEFINER
COMMENT 'EXPORT'
BEGIN

    SELECT
        $Sid    AS Sid,
        $apikey AS apikey,
        $date   AS date,
        $text   AS text,
        $number AS number;

END
//
DELIMITER ;