devart-postgresql-connector 1.2.0__cp313-cp313-win_amd64.whl

devart/postgresql/__init__.py

@@ -0,0 +1,25 @@
+"""
+Python Connector for PostgreSQL is a connectivity solution for accessing
+PostgreSQL databases from Python applications. It fully implements the Python
+DB API 2.0 specification. The connector is distributed as a wheel package
+for Windows, macOS, and Linux.
+ 
+Direct connection
+
+    The connector enables you to establish a direct connection to PostgreSQL from
+    a Python application via TCP/IP, eliminating the need for the database client
+    library. A direct connection increases the speed of data transmission between
+    the application and PostgreSQL database server. It also streamlines
+    the deployment process since you don't have to distribute any client
+    libraries with the application.
+ 
+Secure communication
+
+    The connector supports encrypted communications using SSL/TLS, SSH tunneling,
+    and HTTP/HTTPS tunneling.
+
+Version: 1.2.0 
+
+Homepage: https://www.devart.com/python/postgresql/
+"""
+from .postgresql import *

devart/postgresql/http/tunnel.php

@@ -0,0 +1,743 @@
+<?php
+
+/* ##########################
+
+  Devart HttpTunnel v1.69.    
+
+  HTTP tunnel script.    
+
+  This script allows you to manage server even if the corresponding port is blocked or remote access to server is not allowed.    
+
+  ##########################
+*/
+if ( !function_exists('sys_get_temp_dir')) {
+    function sys_get_temp_dir() {
+        if (!empty($_ENV['TMP'])) { return realpath($_ENV['TMP']); }
+        if (!empty($_ENV['TMPDIR'])) { return realpath( $_ENV['TMPDIR']); }
+        if (!empty($_ENV['TEMP'])) { return realpath( $_ENV['TEMP']); }
+        $tempfile=tempnam(__FILE__,'');
+        if (file_exists($tempfile)) {
+          unlink($tempfile);
+            return realpath(dirname($tempfile));
+        }
+            return false;
+    }
+}
+
+$tmp_dir = sys_get_temp_dir();
+if(!$tmp_dir){
+    define('SYSTEM_TMP_DIR', '');
+}
+else{
+    $last_symbol = substr($tmp_dir, -1);
+    if($last_symbol == DIRECTORY_SEPARATOR){
+        define('SYSTEM_TMP_DIR', $tmp_dir);
+    }
+    else{
+        define('SYSTEM_TMP_DIR', $tmp_dir . DIRECTORY_SEPARATOR);
+    }
+}
+
+$SUB_DIRECTORY = SYSTEM_TMP_DIR . 'tunnel_files';
+$LOG_FILE_NAME = 'httptunnel_server.log';
+$CONN_FILE_NAME = '_connections.id.php';
+$LOGFILE = $SUB_DIRECTORY . '/' . $LOG_FILE_NAME;
+$CONN_FILE = $SUB_DIRECTORY . '/' . $CONN_FILE_NAME;
+
+$LOG = 0;       // Set to "0" to disable logging
+$LOG_DEBUG = 0; // Set to "0" to disable additional debug logging
+$LOGFILEHANDLE = 0;
+$MAXLOGSIZE = "4000000";
+$LIFETIME = 180; // script lifetime in seconds. If script was started and got no client within that time - it exits.
+$READ_WRITE_ATTEMPTS = 100;
+$CREATE_CLIENT_SOCKET_ATTEMPTS = 3;
+$IPC_TMPDIR = "/tmp/"; 
+
+global $SUB_DIRECTORY;
+
+function checkFunctionExists($functionName) {
+  if (!function_exists($functionName)) {
+    echo "Required function <b>$functionName</b> does not exist.</br>";
+    return false;
+  }
+  
+  return true;
+}
+
+// Creates connection temporary  file if not exists and checks permission to write
+function CreateAndCheckConnFile($fileName) {
+
+    global $SUB_DIRECTORY;
+
+  if (file_exists($fileName)){
+      $newFile = @fopen($fileName, 'a');
+      if($newFile)
+         fclose($newFile);
+      else
+         echo "<b>Error</b>: Failed to open ($fileName) file: Permission denied.";
+          
+  }
+  else{
+      if(!is_dir($SUB_DIRECTORY)){
+          mkdir($SUB_DIRECTORY);
+      }
+      $newFile = @fopen($fileName, 'w');
+      if($newFile){
+         fwrite($newFile, "<?php echo 'Devart HTTP tunnel temporary file.'; exit; ?>\r\n"); // forbid viewing this file through browser
+         fclose($newFile);
+      }
+      else
+         echo "<b>Error</b>: Failed to create ($fileName) file: Permission denied.";
+      }
+        
+  if(!$newFile)
+    exit;
+}
+
+if (!isset($_REQUEST["a"])) {  // query from browser
+  
+  echo "Devart HttpTunnel v1.69<br />";
+  
+  $functionList = array(
+    // "set_time_limit",
+    "stream_socket_server",
+    "stream_socket_client",
+    "stream_socket_get_name",
+    "stream_set_blocking",
+    "stream_socket_accept",
+    "stream_select"
+  );
+  
+  $exist = true;
+  foreach($functionList as $functionName) {
+    $result = checkFunctionExists($functionName);
+    $exist = $exist && $result;
+  }
+  
+  if ($exist)
+    CreateAndCheckConnFile($CONN_FILE);
+
+  if ($exist) {
+    echo "Tunnel script is installed correctly. <br />You can establish connections through the HTTP tunnel.";
+    if ($LOG==1)
+      echo "<br /> <br /><b>Loging is enabled.</b><br />Log files are located in the tunnel_files folder, which, in its turn, is located in the temporary folder of the operating system: " .$LOGFILE;
+  }
+  else
+    echo "Required PHP functions listed above are not available. Tunneling script will not work without these functions. Please read PHP manuals about how to install listed functions.";
+
+  exit;
+}
+
+function myErrorHandler($errno, $errstr, $errfile, $errline) {
+  switch ($errno) {
+  case E_ERROR:
+    $errfile = preg_replace('|^.*[\\\\/]|','',$errfile);
+    echo $ERRSTR."Error in line $errline of file $errfile: [$errno] $errstr\n";
+    exit;
+  }
+}
+
+function shutdown () {
+  global $ipsock, $rmsock, $outcount, $incount, $td, $te, $sockname, $useunix;
+  
+  if (connection_status() & 1) { // ABORTED
+    logline ($_SERVER["REMOTE_ADDR"].": Irregular tunnel disconnect -> disconnecting server");
+    logline ($_SERVER["REMOTE_ADDR"].": Sent ".$outcount." bytes, received ".$incount." bytes");
+  } elseif (connection_status() & 2) { // TIMEOUT
+    logline ($_SERVER["REMOTE_ADDR"].": PHP script timeout -> disconnecting server");
+    logline ($_SERVER["REMOTE_ADDR"].": Sent ".$outcount." bytes, received ".$incount." bytes");
+  }
+  
+  if ($ipsock) fclose($ipsock);
+  if ($rmsock) fclose($rmsock);
+}
+
+function logline ($msg) {
+  log_line_to_file(0, $msg);
+}
+
+function logdebug($msg) {
+  log_line_to_file(1, $msg);
+}
+
+function logerr($msg) {
+  global $ERRSTR;
+  logline($msg);
+  echo $ERRSTR;
+  echo $msg;
+}
+
+function log_line_to_file ($debug, $msg) {
+  global $LOG, $LOG_DEBUG, $MAXLOGSIZE, $LOGFILE, $LOGFILEHANDLE;
+  if ($LOG && ((! $debug) || $LOG_DEBUG)) {
+    $LOGFILEHANDLE=fopen ($LOGFILE, "a");
+    if ($LOGFILEHANDLE) {
+      fwrite ($LOGFILEHANDLE, date("d.m.Y H:i:s")." - $msg\r\n");
+      $lstat=fstat($LOGFILEHANDLE);
+      if ($lstat["size"]>$MAXLOGSIZE) rotatelog();
+      fclose($LOGFILEHANDLE);
+    }
+  }
+}
+
+function rotatelog() {
+  global $LOG, $MAXLOGSIZE, $LOGFILE, $LOGFILEHANDLE;
+  if ($LOG) {
+    fwrite ($LOGFILEHANDLE, date("d.m.Y H:i:s")." - Logfile reached maximum size ($MAXLOGSIZE)- rotating.\r\n");
+    fclose ($LOGFILEHANDLE);
+		rename ($LOGFILE, substr_replace($LOGFILE,md5(microtime()),-3).".log");
+    $LOGFILEHANDLE=fopen ($LOGFILE, "a");
+    if (!$LOGFILEHANDLE)
+      $LOG=0;
+    else 
+      fwrite ($LOGFILEHANDLE, date("d.m.Y H:i:s")." - Opening new Logfile.\r\n");
+  }
+}
+
+function create_client_socket() {
+  global $CREATE_CLIENT_SOCKET_ATTEMPTS, $_REQUEST, $IPC_TMPDIR;
+  
+  if (!isset($_REQUEST["port"])) {
+    echo $ERRSTR."Port not set.";
+    return 0;
+  }
+  
+  $port = $_REQUEST["port"];
+  $useunix = in_array("unix", stream_get_transports());
+  
+  $retryCount = 0;
+  do {
+    if ($retryCount > 0) {
+      usleep(10000); // 10ms
+      logdebug("Attempt to create client socket #".($retryCount + 1)." ErrorCode:".$errcode." ErrorMessage:".$errmessage." Port:".$port);
+    }
+        
+    if ($useunix) { // this is for the unix socket type
+      $sockname = preg_replace('/\\\\/','/', $IPC_TMPDIR."tun$port.sock");
+      $client = stream_socket_client("unix://".$sockname, $errcode, $errmessage);
+    }
+    else {
+      $client = stream_socket_client("tcp://127.0.0.1:".$port, $errcode, $errmessage);
+    }
+    $retryCount = $retryCount + 1;
+  } while(!$client && $retryCount < $CREATE_CLIENT_SOCKET_ATTEMPTS);
+
+  if ($client) {
+    stream_set_blocking($client, 1);
+  }
+  return $client;
+}
+
+function send_server_script_message($command) {
+  global $_REQUEST;
+  
+  $client = create_client_socket();
+  if (!$client) {
+    logerr("Failed to create client socket");
+    return FALSE;
+  }
+  if (fwrite($client, $command, 1) === FALSE) {
+    logerr("Failed to send message to server script.");
+    fclose($client);
+    return FALSE;
+  }
+  fclose($client);
+  return TRUE;
+}
+
+function increase_script_lifetime() {
+  global $LIFETIME;
+  if (function_exists("set_time_limit")) {
+    set_time_limit($LIFETIME);
+    logdebug("Script liftetime incremented with $LIFETIME");
+  }
+}
+
+function write_to_socket($socket, $buffer, $count) {
+  global $READ_WRITE_ATTEMPTS;
+  
+  $totalCount = 0;
+  $retryCount = 0;
+  
+  do {
+    if ($retryCount > 0)
+      usleep(10000); // 10ms
+    
+    if (!$socket)
+      break;
+    
+    $written = fwrite($socket, $buffer, $count);
+    $buffer = substr($buffer, $written);
+    $totalCount += $written;
+    
+    if ($retryCount > 0)
+      logdebug("Attempt to write #".($retryCount + 1)." Write: ".$written);
+    
+    if ($written <= 0)
+      $retryCount = $retryCount + 1;
+    
+  } while($totalCount < $count && $retryCount < $READ_WRITE_ATTEMPTS);
+  
+  if ($totalCount != $count)
+    logline("ERROR: Failed to write to socket $count bytes, $totalCount actually written.");
+  
+  return $totalCount;
+}
+
+// reads specified byte count from socket
+function read_from_socket($socket, &$buffer, $count) {
+  global $READ_WRITE_ATTEMPTS;
+  
+  $totalCount = 0;
+  $retryCount = 0;
+  
+  $buffer = "";
+  $readBuffer;
+  
+  do {
+    if ($retryCount > 0)
+      usleep(10000); // 10ms
+    
+    if (!$socket)
+      break;
+    
+    $readBuffer = fread($socket, $count);
+    $read = strlen($readBuffer);
+    $buffer = $buffer.$readBuffer;
+    
+    if ($retryCount > 0)
+      logdebug("Attempt to read #".($retryCount + 1)." Read: ".$read);
+    
+    $totalCount += $read;
+    if ($read <= 0)
+      $retryCount = $retryCount + 1;
+    
+  } while($totalCount < $count && $retryCount < $READ_WRITE_ATTEMPTS);
+  
+  if ($totalCount != $count)
+    logerr("Failed to read from socket $count bytes, $totalCount actually read.");
+  
+  return $totalCount;
+}
+
+// packet:  size of data count |                      data count | data
+// lengths:             1 byte | up to 255 bytes, typically 1 - 5| up to $MaxCount
+function write_data_packet($socket, &$buffer, $count) {
+  
+  $countLength = strlen($count);
+  // write length of data count digit
+  write_to_socket($socket, $countLength, 1);
+  // write data count
+  write_to_socket($socket, $count, $countLength);
+  // write data
+  $writeCount = write_to_socket($socket, $buffer, $count);
+  if ($writeCount == $count)
+    return $writeCount;
+  else
+    return 0;
+}
+
+function read_data_packet($socket, &$buffer) {
+  
+  // obtain data length digit length
+  read_from_socket($socket, $countSize, 1);
+  // read data length
+  read_from_socket($socket, $readCount, $countSize);
+  $expectedReadCount = $readCount;
+  // read data
+  $readCount = read_from_socket($socket, $buffer, $readCount);
+  if ($readCount == $expectedReadCount)
+    return $readCount;
+  else
+    return FALSE;
+}
+
+// Start of the tunnel script
+$isServer = FALSE;
+
+if (version_compare("5.0.0", phpversion())==1) die ("Only PHP 5 or above supported");
+error_reporting(0);
+set_error_handler("myErrorHandler");
+register_shutdown_function ("shutdown");
+// no-cache
+Header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
+Header("Cache-Control: no-cache, must-revalidate");
+Header("Pragma: no-cache"); // HTTP/1.1 
+Header("Last-Modified: ".gmdate("D, d M Y H:i:s")."GMT");
+Header("Content-Type: application/octet-stream");
+
+ob_implicit_flush();
+
+// Maximum bytes to read at once
+$MaxReadCount = 16*1024;
+
+// operation success identification
+$OKSTR = "OK:";
+$ERRSTR = "ER:";
+
+$CONN_FILE_MAXSIZE = 100;
+
+// Primary tunnel connection
+// need the following REQUEST vars:
+// a: "c"
+// s: remote server name
+// p: remote server port
+
+// every operation output at least first three chars identifying the success of operation: "OK:" if succeeded, "ER:" if not.
+//
+
+if ($_REQUEST["a"]=="c") {  // run server script
+  $isServer=TRUE;
+  // clear log
+  if ($LOG_DEBUG) {
+    // truncate log file
+    $logfile = fopen($LOGFILE, 'w');
+    fclose($logfile);
+  }
+
+  $useunix = in_array("unix", stream_get_transports());
+  $dad = $_REQUEST["s"];
+  $dpo = $_REQUEST["p"];
+
+  // open the interprocess socket
+  $errno = 0;
+  $errstr = "";
+  $ipsock = stream_socket_server("tcp://127.0.0.1:0", $errno, $errstr);
+
+  if (!$ipsock) {
+    logerr("stream_socket_server() failed: reason:".$errno." ".$errstr);
+    exit;
+  }
+
+  $port = stream_socket_get_name($ipsock, false);
+  $port = preg_replace('/^.*?:/','', $port);
+  
+  if ($useunix) { // this is for the unix socket type
+    if ($ipsock) fclose($ipsock);
+    $ipsock = 0;
+    $sockname = preg_replace('/\\\\/','/', $IPC_TMPDIR."tun$port.sock");
+    unlink($sockname);
+    if (file_exists($sockname)) {
+      logerr("Temporary UNIX socket exists and cannot be deleted ($sockname)");
+      exit;
+    }
+    $ipsock = stream_socket_server("unix://".$sockname, $errno, $errstr);
+    if (!$ipsock) {
+      logerr("stream_socket_server() failed: reason:".$errno." ".$errstr);
+      exit;
+    }
+  }
+
+  stream_set_blocking($ipsock, 1);
+  
+  // open the remote socket
+  logline("Connecting to remote  $dad: $dpo");
+  $rmsock = stream_socket_client("tcp://".$dad.":".$dpo, $errno, $errstr);
+  
+  if (!$rmsock) {
+    logerr("Failed to create remote socket at $dad: $dpo. ".$errno." ".$errstr);
+    exit;
+  }
+  else {
+    if (isset($_REQUEST["nonblock"]))
+      $block = 0;
+    else
+      $block = 1;
+    stream_set_blocking($rmsock, $block);
+    logline("Connected to remote  $dad: $dpo");
+  }
+  
+  // write connection identificator to file. Echo'ing is not appropriate in case of antiviral software, it would be blocked until script finishes
+  $newConnFile = FALSE;
+  $connFileMode = "a";
+  
+  if (file_exists($CONN_FILE)) {
+    $connFile = fopen($CONN_FILE, "r");
+    $lstat=fstat($connFile);
+    fclose($connFile);
+    if ($lstat["size"]>$CONN_FILE_MAXSIZE) {
+      $connFileMode = "w";
+      $newConnFile = TRUE;
+    }
+  }
+  else {
+    $newConnFile = TRUE;
+  }
+  
+  $connFile = fopen($CONN_FILE, $connFileMode);
+  if ($connFile) {
+    if ($newConnFile) {
+      fwrite($connFile, "<?php echo 'Devart HTTP tunnel temporary file.'; exit; ?>\r\n"); // forbid viewing this file through browser
+    }
+    $connectionId = str_replace("_", " ", $_REQUEST["id"]);
+    fwrite ($connFile, $connectionId." ".$port."\r\n");
+    fclose($connFile);
+  }
+  else {
+    logerr("Failed to create connection temporary file.");
+    exit;
+  }
+  
+  if (function_exists("set_time_limit")) {
+    set_time_limit($LIFETIME);
+  }
+    
+  $exit = false;
+  $buffer = array();
+  $countBuffer = array();
+  
+  while (!$exit) {
+    logdebug("Waiting for client...");
+    $client = stream_socket_accept($ipsock);
+    logline("Client accepted");
+    if ($client === FALSE) {
+      logline("ERROR: Bad client.");
+      continue;
+    }
+    // read command
+    $count = read_from_socket($client, $buffer, 1);
+    if ($count == 0) {
+      logline("Error reading client command.");
+      $exit = true;
+    }
+    
+    logdebug("Read from client ($count): ".$buffer[0]);
+    
+    $command = $buffer[0];
+    
+    increase_script_lifetime();
+    
+    if ($command == "x") {  // close
+      logline("Shutting down on client request.");
+      $exit = true;  // shutdown
+    }
+    else if ($command == "r") { // read
+      if (!$rmsock) {
+        logline("ERROR: rmsock is off");
+        $exit = true;
+        break;
+      }
+      
+      $readCount = 0;
+      $buffer = fread($rmsock, $MaxReadCount);
+      if ($buffer === FALSE) {
+        logline("ERROR: Remote server disconnected.");
+        $exit = true;
+        break;
+      }
+      else {
+        $readCount = strlen($buffer);
+        logline("Read from remote:($readCount)");
+      }
+      
+      if ($readCount >= 0) {
+        if ($readCount == 0)
+          logline("Nothing to read from remote.");
+        
+        $writeCount = write_data_packet($client, $buffer, $readCount);
+        logdebug("Write to client($writeCount): $buffer");
+        if ($readCount > 0 && $writeCount == 0) {
+          logerr("Failed to write to client.");
+          $exit = true;
+        }
+      }
+    }
+    else if ($command == "s") { // select
+      if (!$rmsock) {
+        logline("ERROR: rmsock is off");
+        $exit = true;
+        break;
+      }
+
+      $readSocks = array($ipsock, $rmsock);
+	    $writeSocks = NULL;
+	    $exceptSocks = NULL;
+      if (!stream_select($readSocks, $writeSocks, $exceptSocks, NULL)) 
+        $res = $ERRSTR;
+      else 
+        if (in_array($rmsock, $readSocks))
+          $res = $OKSTR;
+        else
+          $res = $ERRSTR;
+      $writeCount = write_to_socket($client, $res, strlen($res));
+      logdebug("Write to client($writeCount): $res");
+    }
+    else if ($command == "w") { // write
+      if (!$rmsock) {
+        logline("ERROR: rmsock is off");
+        $exit = true;
+        break;
+      }
+      $readCount = read_data_packet($client, $buffer);
+      logline("Read from client: $readCount");
+      if ($readCount > 0) {
+        $writeCount = write_to_socket($rmsock, $buffer, $readCount);
+        logdebug("Write to remote($writeCount): $buffer");
+      }
+    }
+    else if ($command == "l") {   // increment lease time
+      logline("Lease time increased.");
+    }
+    else if ($command == "t") {  // test connection command
+      $writeCount = write_to_socket($client, $OKSTR, strlen($OKSTR));
+      if ($writeCount == 0)
+        $exit = true;
+    }
+    else {
+      logline("ERROR: Unknown command: $command. Exiting.");
+      $exit = true;
+    }
+  }
+  
+  logline("Server script closed.");
+  exit;
+}
+
+if ($_REQUEST["a"]=="r") {  // read
+  
+  $client = create_client_socket();
+  if (!$client) {
+    logerr("Failed to connect to server script.");
+    exit;
+  }
+  
+  logdebug("Client: Reading from server script");
+  
+  if (write_to_socket($client, "r", 1) == 0) { // write "Read" command
+    logerr("Write to server script failed.");
+    fclose($client);
+    exit;
+  }
+  
+  $buffer;
+  $readCount = read_data_packet($client, $buffer);
+  if ($readCount === FALSE) {
+    logerr("Failed to read response from server script.");
+    fclose($client);
+    exit;
+  }
+  
+  $totalCount = strlen($OKSTR) + $readCount;
+  
+  $outputStr = $OKSTR.$buffer;
+  
+  header("Content-Length: ".$totalCount);
+  header("Content-Type: application/octet-stream");
+  
+  logline("Client: Read from server $readCount");
+  echo $outputStr;
+  
+  fclose($client);
+  exit;
+}
+
+if ($_REQUEST["a"]=="s") {  // select
+  
+  $client = create_client_socket();
+  if (!$client) {
+    logerr("Failed to connect to server script.");
+    exit;
+  }
+  
+  logdebug("Client: Selecting from server script");
+  
+  if (write_to_socket($client, "s", 1) == 0) { // write "Select" command
+    logerr("Write to server script failed.");
+    fclose($client);
+    exit;
+  }
+
+  $buffer;
+  $count = read_from_socket($client, $buffer, 3);
+  if ($count < 3) {
+    logerr("Failed to read response from server script.");
+    fclose($client);
+    exit;
+  }
+
+  fclose($client);
+  echo $buffer;
+  exit;
+}
+
+if ($_REQUEST["a"]=="w") {  // write
+  
+  $client = create_client_socket();
+  if (!$client) {
+    logerr("Failed to connect to server script.");
+    exit;
+  }
+  
+  $postBody= isset($_POST['base64body'])?base64_decode($_POST['base64body']):file_get_contents("php://input");  // Retrieve RAW POST data	
+  $writeData = $postBody;
+  $expectedWriteCount = strlen($writeData);
+  $writeCount = write_to_socket($client, "w", 1);  // indicate that this is the "Write" command
+  if ($writeCount > 0)
+    $writeCount = write_data_packet($client, $writeData, $expectedWriteCount);
+  
+  if ($writeCount == 0) {
+    logerr("Write to server script failed.");
+    fclose($client);
+    exit;
+  }
+  
+  logdebug("Client: Written $writeCount");
+  
+  fclose($client);
+  echo $OKSTR;
+  exit;
+}
+
+if ($_REQUEST["a"]=="x") {  // close
+  
+  echo $OKSTR."Shutted down.";
+  send_server_script_message("x");
+  exit;
+}
+
+if ($_REQUEST["a"] == "l") { // increment server script lease time
+  
+  if (send_server_script_message("l"))
+    echo $OKSTR."Incremented server script lease time.";
+  exit;
+}
+
+if ($_REQUEST["a"] == "t") { // test newly created connection
+  
+  $connectionId = str_replace("_", " ", $_REQUEST["id"]);
+  logline($connectionId);
+  $connections = file_get_contents($CONN_FILE);
+  
+  if ($connections === FALSE) {
+    logerr("Failed to open $CONN_FILE.");
+    exit;
+  }
+  
+  $lines = explode("\r\n", $connections);
+  
+  // skip first line
+  for($i = 1; $i < count($lines); ++$i) {
+    $line = $lines[$i];
+    $pos = strpos($line, $connectionId);
+    if ($pos === FALSE)
+      continue;
+    
+    if ($pos === 0) {  // starts with
+      $parts = explode(" ", $line);
+      if (count($parts) != 3) {
+        echo "Invalid connection record";
+        exit;
+      }
+      
+      echo $OKSTR.$parts[2]."\n"."$LIFETIME\n";
+      exit;
+    }
+  }
+  
+  logerr("Connection entry not found.");
+  exit;
+}
+
+logerr("Invalid tunneling script parameter: ".$_REQUEST["a"]);
+
+?>

devart/postgresql/postgresql.pyi

@@ -0,0 +1,403 @@
+from typing import Tuple, List, Optional, Any, Dict
+import datetime
+import array
+
+class description(object):
+    """
+    The description class describes a column in a rowset returned by the cursor.
+    """
+    name: str
+    """
+    The name of the column in the rowset.
+    """
+    type_code: int
+    """
+    The database type code that corresponds to the type of the column.
+    """
+    display_size: int
+    """
+    The actual length of the column in characters for a character column, `None` otherwise.
+    """
+    internal_size: int
+    """
+    The size in bytes used by the connector to store the column data.
+    """
+    precision: int
+    """
+    The total number of significant digits for a numeric column, `None` otherwise.
+    """
+    scale: int
+    """
+    The number of digits in the fractional part for a numeric column, `None` otherwise.
+    """
+    null_ok: bool
+    """
+    `Py_True` if the corresponding database column accepts `NULL` values, `Py_False` otherwise.
+    """
+    ...
+
+class cursor(object):
+    """
+    The `cursor` class represents a database cursor, which is used to manage
+    the context of fetch operations. This class provides methods for executing SQL
+    statements and operating rowsets. Cursors are created using the `cursor()`
+    connection method.
+    """
+    connection: str
+    """
+    A read-only attribute that specifies the `connection` object
+    to which the cursor belongs.
+    """
+    arraysize: int
+    """
+    A read/write attribute that specifies the number of rows to fetch at a time
+    with the `fetchmany()` method.
+    """
+    description: Tuple[description]
+    """
+    A read-only attribute that describes the columns in a rowset returned
+    by the cursor.
+    """
+    rowcount: int
+    """
+    A read-only attribute that specifies the number of rows that the last
+    `execute()` call produced by a `SELECT` statement or affected by `UPDATE` or
+    `INSERT` statements.
+    """
+    rownumber: int
+    """
+    A read-only attribute that specifies the current 0-based index of the cursor
+    in the result set.
+    """
+    lastrowid: None
+    """
+    This read-only attribute is provided for compatibility with the DB API 2.0
+    specification. It currently returns `None`.
+    """
+    def setinputsizes(self, sizes: Optional[List[Any] | Tuple[Any]]) -> None:
+        """
+        Predefines the types of parameters for the further call to the `execute*()`
+        method.
+        """
+        ...
+    def execute(self, operation: str, parameters: Optional[List[Any] | Tuple[Any] | Dict[str, Any]]) -> cursor:
+        """
+        Prepares and executes a database operation.
+        """
+        ...
+    def executemany(self, operation: str, parameters: Optional[List[Any] | Tuple[Any] | Dict[str, Any]]) -> cursor:
+        """
+        Prepares and executes a batch database operation.
+        """
+    def fetchone(self) -> Tuple[Any]:
+        """
+        Fetches the next row of a query result set.
+        """
+        ...
+    def fetchmany(self, size: Optional[int]) -> List[Tuple[Any]]:
+        """
+        Fetches the next set of rows of a query result.
+        """
+        ...
+    def fetchall(self) -> List[Tuple[Any]]:
+        """
+        Fetches all remaning rows of a query result.
+        """
+        ...
+    def next(self) -> Tuple[Any]:
+        """
+        Returns the next row from the currently executed SQL statement.
+        """
+        ...
+    def scroll(value: int, mode: Optional[str]) -> bool:
+        """
+        Scrolls the cursor in the result set to a new position.
+        """
+        ...
+    def addtypecast(self, column: int | dbtype | str | description | Dict[str, type], python_type: Optional[type]) -> None:
+        """
+        Defines a data type cast rule to use when fetching data from the cursor.
+        """
+        ...
+    def cleartypecast(self) -> None:
+        """
+        Removes all data type cast rules defined for the cursor.
+        """
+        ...
+    def close(self) -> None:
+        """
+        Closes the cursor.
+        """
+        ...
+    def setoutputsize(size: int, column: Optional[int]):
+        """
+        This method is provided for compatibility with the DB API 2.0 specification.
+        It currently does nothing but is safe to call.
+        """
+        ...
+
+class connection(object):
+    """
+    The `connection` class encapsulates a database session. It provides methods
+    for creating cursors, type casting, and transaction handling. Connections
+    are created using the `connect()` module method.
+    """
+    connectstring: str
+    """
+    A read-only attribute that returns a string literal of the form
+    `"parameter=value;parameter=value"` that contains the parameters
+    for the current connection.
+    """
+    def cursor(self) -> cursor:
+        """
+        Creates a new cursor object, which is used to manage the context of fetch
+        operations.
+        """
+        ...
+    def close(self) -> None:
+        """
+        Closes the connection.
+        """
+        ...
+    def commit(self) -> None:
+        """
+        Commits any pending transaction to the database.
+        """
+        ...
+    def rollback(self) -> None:
+        """
+        Causes the database to roll back any pending transaction.
+        """
+        ...
+    def addtypecast(self, column: int | dbtype | str | description | Dict[str, type], python_type: Optional[type]) -> None:
+        """
+        Defines a data type cast rule to use when fetching data from the cursor.
+        """
+        ...
+    def cleartypecast(self) -> None:
+        """
+        Removes all data type cast rules defined for the connection.
+        """
+        ...
+
+class connection_pool(object):
+    """
+    Description of the `connection_pool` class is not available yet.
+    """
+    enabled: bool = False
+    """
+    Description of the `enabled` attribute is not available yet.
+    """
+    max_size: int = 1000
+    """
+    Description of the `max_size` attribute is not available yet.
+    """
+    min_size: int = 1000
+    """
+    Description of the `min_size` attribute is not available yet.
+    """
+    lifetime: int = 0
+    """
+    Description of the `lifetime` attribute is not available yet.
+    """
+    validate: bool = False
+    """
+    Description of the `validate` attribute is not available yet.
+    """
+
+class Warning(Exception):
+    """
+    This exception is raised for important warnings like data truncations while
+    inserting, etc. The `Warning` exception is a subclass of the Python
+    `Exception` class.
+    """
+    ...
+
+class Error(Exception): 
+    """
+    This exception is the base class of all error exceptions. You can use
+    it to catch all errors with a single `except` statement. The `Error` exception
+    is a subclass of the Python `Exception` class.
+    """
+    ...
+
+class InterfaceError(Error): 
+    """
+    This exception is raised for errors that are related to the database interface
+    rather than the database itself. The `InterfaceError` exception is a subclass
+    of `Error`.
+    """
+    ...
+
+class DatabaseError(Error): 
+    """
+    This exception is raised for errors that are related to the database.
+    The `DatabaseError` exception is a subclass of `Error`.
+    """
+    ...
+
+class DataError(DatabaseError): 
+    """
+    This exception is raised for errors caused by issues with the processed data
+    like division by zero, numeric value out of range, etc. The `DataError`
+    exception is a subclass of `DatabaseError`.
+    """
+    ...
+
+class OperationalError(DatabaseError): 
+    """
+    This exception is raised for errors that are related to the database operation
+    and not necessarily under the control of the developer, for example,
+    an unexpected disconnect occurs, the data source name isn't found,
+    a transaction couldn't be processed, a memory allocation error occurred
+    during processing, etc. The OperationalError exception is a subclass
+    of `DatabaseError`.
+    """
+    ...
+
+class IntegrityError(DatabaseError): 
+    """
+    This exception raised when the relational integrity of the database
+    is affected, for example, a foreign key check fails. The `IntegrityError`
+    exception is a subclass of `DatabaseError`.
+    """
+    ...
+
+class InternalError(DatabaseError): 
+    """
+    This exception is raised when the database encounters an internal error,
+    for example, the cursor isn't valid anymore, the transaction is out of sync,
+    etc. The `InternalError` exception is a subclass of `DatabaseError`.
+    """
+    ...
+
+class ProgrammingError(DatabaseError): 
+    """
+    This exception is raised for programming errors, for example, table not found
+    or already exists, syntax error in the SQL statement, wrong number
+    of parameters specified, etc. The `ProgrammingError` exception is a subclass
+    of `DatabaseError`.
+    """
+    ...
+
+class NotSupportedError(DatabaseError): 
+    """
+    This exception is raised when a method or database API isn't supported
+    by the database, for example, requesting a `rollback()` on a connection
+    that doesn't support transactions or has transactions turned off.
+    The `NotSupportedError` exception is a subclass of `DatabaseError`.
+    """
+    ...
+
+class binary(object):
+    """
+    This type object describes an object that holds binary data. By default, this
+    type object is used to fetch BLOB-based columns from the cursor. You can also
+    create a `binary` object using the `Binary()` constructor.
+    """
+    value: bytes
+    """
+    A value of type `bytes` that represents binary data. This is a read/write attribute
+    that accepts values of type `str`, `bytes`, `bytearray`, `array.array`, and `binary`.
+    """
+
+class dbtype(object):
+    name: str
+    values: Dict[int, str]
+
+apilevel: str = "2.0"
+"""
+Indicates the DB API level supported by the module. Returns a string value "2.0".
+"""
+
+threadsafety: int = 2
+"""
+Indicates the thread safety level of the module. Returns an integer value `2` that means
+that threads may share the module and connections.
+"""
+
+paramstyle: str = "named"
+"""
+Indicates the type of parameter marker formatting expected by the module. 
+Returns a string value "named" that means that the module supports named style parameters,
+for example, `...WHERE name=:name`.
+"""
+
+def connect(connection_string: str, **kwargs: Optional[Any]) -> connection: 
+    """
+    Creates a new connection to the database.
+    """
+    ...
+
+def Date(year: int, month: int, day: int) -> datetime.date: 
+    """
+    Creates an object that holds a date value.
+    """
+    ...
+
+def Time(hour: int, minute: int, second: int | float, timezone: Optional[datetime.tzinfo]) -> datetime.time:
+    """
+    Creates an object that holds a time value.
+    """
+    ...
+
+def Timestamp(year: int, month: int, day: int, hour: Optional[int], minute:Optional[int], second: Optional[int | float], timezone: Optional[datetime.tzinfo]) -> datetime.datetime:
+    """
+    Creates an object that holds a timestamp value.
+    """
+    ...
+
+def DateFromTicks(ticks: float) -> datetime.date:
+    """
+    Creates an object that holds a date value from the given ticks value
+    (the number of seconds since the Unix epoch). For more information, see
+    the `time` module in the standard Python documentation.
+    """
+    ...
+
+def TimeFromTicks(ticks: float) -> datetime.time:
+    """
+    Creates an object that holds a time value from the given ticks value (number
+    of seconds since the Unix epoch). For more information, see the `time` module
+    in the standard Python documentation.
+    """
+    ...
+
+def TimestampFromTicks(ticks: float) -> datetime.datetime:
+    """
+    Creates an object that holds a timestamp value from the given ticks value
+    (number of seconds since the Unix epoch). For more information, see the `time`
+    module in the standard Python documentation.
+    """
+    ...
+
+def Binary(value: str | bytes | bytearray | array.array) -> binary:
+    """
+    Creates an object that holds binary data.
+    """
+    ...
+
+STRING: dbtype
+"""
+This type object describes string-based columns in a database.
+"""
+
+BINARY: dbtype
+"""
+This type object describes binary columns in a database.
+"""
+
+NUMBER: dbtype
+"""
+This type object describes numeric columns in a database.
+"""
+
+DATETIME: dbtype
+"""
+This type object describes date/time columns in a database.
+"""
+
+ROWID: dbtype
+"""
+This type object describes the `row id` columns in a database.
+"""

devart/postgresql/sqlalchemy/__init__.py

@@ -0,0 +1,17 @@
+from sqlalchemy.dialects import registry
+from sqlalchemy.dialects.postgresql.base import PGDialect
+
+registry.register('devart.postgresql', 'devart.postgresql.sqlalchemy', 'DevartPostgreSqlDialect')
+
+class DevartPostgreSqlDialect(PGDialect):
+    driver = "devart"
+    name = "postgresql"
+
+    supports_statement_cache = False
+    supports_server_side_cursors = False
+    default_paramstyle = "named"
+
+    @classmethod
+    def import_dbapi(cls):
+        import devart.postgresql
+        return devart.postgresql

devart_postgresql_connector-1.2.0.dist-info/LICENSE

@@ -0,0 +1,85 @@
+Python Connector License Agreement
+Copyright 2022-2024, Devart. All Rights Reserved
+--------------------------------------------------
+
+PLEASE READ THIS LICENSE AGREEMENT CAREFULLY. BY INSTALLING OR USING THIS SOFTWARE, YOU INDICATE ACCEPTANCE OF AND AGREE TO BECOME BOUND BY THE TERMS AND CONDITIONS OF THIS LICENSE. IF YOU DO NOT AGREE TO THE TERMS OF THIS LICENSE, DO NOT INSTALL OR USE THIS SOFTWARE AND PROMPTLY RETURN IT TO DEVART.
+
+INTRODUCTION
+
+This Devart end-user license agreement ("Agreement") is a legal agreement between you (either an individual person or a single legal entity) and Devart, for the use of the Python Connector software application, demos, intermediate files, printed materials, and online or electronic documentation contained in this installation file. For the purpose of this Agreement, the software program(s) and supporting documentation will be referred to as the "Software".
+
+LICENSE
+
+1. GRANT OF LICENSE
+
+The enclosed Software is licensed, not sold. You have the following rights and privileges, subject to all limitations, restrictions, and policies specified in this Agreement.
+
+1.1. If you are a legally licensed user, depending on the License Type specified in the registration letter you have received from Devart upon purchase of the Software:
+- the "Single License" allows you to install and use the Software on one or more computers, provided it is used by 1 (one) user for the sole purposes of developing, testing, and deploying scripts or applications in a single company at one physical address in accordance with this Agreement;
+- the "Team License" allows you to install and use the Software on one or more computers, provided it is used by up to 4 (four) users for the sole purposes of developing, testing, and deploying scripts or applications in a single company at one physical address in accordance with this Agreement;
+- the "Site License" allows you to install and use the Software on one or more computers, provided it is used by unlimited number of users for the sole purposes of developing, testing, and deploying scripts or applications in a single company at one physical address in accordance with this Agreement;
+- the "OEM License" allows you to install and use the Software as part of a licensee's script or application that can be deployed to web servers, application servers, batch servers, desktops, and other end-user devices. This definition includes the ability to install and use the script or application containing the Software an unlimited number of times, without any additional fees in favor of the licensor.
+
+1.2. If you are a legally licensed user, depending on the License Type specified in the registration letter you have received from Devart upon purchase of the Software:
+- the "Subscription-based License" allows you to install and use the Software on a single computer only during the subscription term specified at purchase. An Internet connection is required to activate the license and check the license status when the Software is used. Once the subscription term is over, you will be able to either stop using the Software or renew the license for a new subscription term;
+- the "Perpetual License" allows you to install and use the specific Software product version on a single computer without an active subscription. A subscription provides access to new product releases, regular upgrades, and support for new server versions provided during the subscription term;
+
+1.3. If you are a legally licensed user of the Software, you are also entitled to:
+- make one copy of the Software for archival purposes only, or copy the Software onto the hard disk of your computer and retain the original for archival purposes;
+- develop and test Applications with the Software, subject to the Limitations below.
+
+1.4. If you have the "OEM License", you are also entitled to:
+- make any number of copies of the Software to deploy it to your end-user.
+- deploy the Software to your end-user as a Software installation package or integrate it into your Applications.
+
+1.5. You are allowed to use evaluation versions of the Software as specified in the Evaluation section.
+
+No other rights or privileges are granted in this Agreement.
+
+2. LIMITATIONS
+
+Only legally registered users are licensed to use the Software, subject to all of the conditions of this Agreement. Usage of the Software is subject to the following restrictions.
+
+2.1. You may not reverse engineer, decompile, or disassemble the Software.
+
+2.2. You may not build any other Python packages through inheritance for public distribution or commercial sale.
+
+2.3. You may not reproduce or distribute any Software documentation without express written permission from Devart.
+
+2.4. You may not distribute and sell any portion of the Software integrating it into your Applications.
+
+2.5. You may not transfer, assign, or modify the Software in whole or in part. In particular, the Software license is non-transferable, and you may not transfer the Software installation package.
+
+2.6. You may not remove or alter any Devart's copyright, trademark, or other proprietary rights notice contained in any portion of Devart files.
+
+3. REDISTRIBUTION
+
+The license grants you a non-exclusive right to reproduce any new software programs (Applications) created using the Software. You cannot distribute the Software integrated into your Applications unless you are an "OEM License" holder. Any Devart's files remain Devart's exclusive property.
+
+4. TRANSFER
+
+You may not transfer the Software to any individual or entity without express written permission from Devart. In particular, you may not share copies of the Software under �Single License� and �Team License� with other co-developers without obtaining proper license of these copies for each individual.
+
+5. TERMINATION
+
+Devart may immediately terminate this Agreement without notice or judicial resolution in the event of any failure to comply with any provision of this Agreement. Upon such termination you must destroy the Software, all accompanying written materials, and all copies.
+
+6. EVALUATION
+
+Devart may provide evaluation ("Trial") versions of the Software. You may transfer or distribute Trial versions of the Software as an original installation package only. If the Software you have obtained is marked as a "Trial" version, you may install and use the Software for a period of up to 30 calendar days from the date of installation (the "Trial Period"), subject to the additional restriction that it is used solely for evaluation of the Software and not in conjunction with the development or deployment of any application in production. You may not use Applications developed using Trial versions of the Software for any commercial purposes. Upon expiration of the Trial Period, the Software must be uninstalled, all its copies and all accompanying written materials must be destroyed.
+
+7. WARRANTY
+
+The Software and documentation are provided "AS IS" without warranty of any kind. Devart makes no warranties, expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose or use.
+
+8. SUBSCRIPTION AND SUPPORT
+
+The Software is sold on a subscription basis. The Software subscription entitles you to download improvements and enhancement from Devart's web site as they become available, during the active subscription period. The initial subscription period is one year from the date of purchase of the license. The subscription is automatically activated upon purchase, and may be subsequently renewed by Devart, subject to receipt applicable fees. Licensed users of the Software with an active subscription may request technical assistance with using the Software over email from the Software development. Devart shall use its reasonable endeavors to answer queries raised, but does not guarantee that your queries or problems will be fixed or solved.
+
+Devart reserves the right to cease offering and providing support for legacy Python and Database versions.
+
+9. COPYRIGHT
+
+The Software is confidential and proprietary copyrighted work of Devart and is protected by international copyright laws and treaty provisions. You may not remove the copyright notice from any copy of the Software or any copy of the written materials, accompanying the Software.
+
+This Agreement contains the total agreement between the two parties and supersedes any other agreements, written, oral, expressed, or implied.

devart_postgresql_connector-1.2.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: devart-postgresql-connector
+Version: 1.2.0
+Summary: New level of functionality and performance in data access via Python
+Home-page: https://devart.com
+Author: Devart
+Author-email: support@devart.com
+License: Other/Proprietary License
+Project-URL: Homepage, http://devart.com/python/postgresql
+Project-URL: Download, http://devart.com/python/postgresql/download.html
+Project-URL: History, http://devart.com/python/postgresql/revision_history.html
+Project-URL: License, https://www.devart.com/python/eula.html
+Project-URL: Documentation, http://docs.devart.com/python/postgresql/overview.htm
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python Connector for PostgreSQL #
+
+Python Connector for PostgreSQL is a connectivity solution for accessing
+PostgreSQL databases from Python applications. It fully implements the Python
+DB API 2.0 specification. The connector is distributed as a wheel package
+for Windows, macOS, and Linux.
+
+Direct connection
+
+The connector enables you to establish a direct connection to PostgreSQL from
+a Python application via TCP/IP, eliminating the need for the database client
+library. A direct connection increases the speed of data transmission between
+the application and PostgreSQL database server. It also streamlines
+the deployment process since you don't have to distribute any client
+libraries with the application.
+
+Secure communication
+
+The connector supports encrypted communications using SSL/TLS, SSH tunneling,
+and HTTP/HTTPS tunneling.
+
+## Using the connector ##
+
+To retrieve data from a database:
+
+Import the module.
+```
+import devart.postgresql
+```
+
+Connect to a database using the `connect()` module method and obtain a `connection` object.
+```
+my_connection = devart.postgresql.connect(
+    Server="your_server",
+    Database="your_database",
+    UserId="your_username",
+    Password="your_password"
+)
+```
+
+Create a `cursor` object using the `cursor()` connection method.
+```
+my_cursor = my_connection.cursor()
+```
+
+Execute the SQL statement using the `execute()` cursor method.
+```
+my_cursor.execute("SELECT * FROM employees")
+```
+
+Retrieve the result set using one of the `fetch*()` cursor methods.
+```
+for row in my_cursor.fetchall(): 
+    print(row)
+```
+
+## Ordering and activating the license ##
+
+You can purchase a license for the connector on the ordering page:             
+https://www.devart.com/python/postgresql/ordering.html
+
+To activate the license, follow the instructions in the documentation:             
+https://docs.devart.com/python/postgresql/activate-a-license.htm
+
+## What's new ##
+
+Python Connector for PostgreSQL 1.2
+
+- Added support for Python 3.13
+- Added support for PostgreSQL 17
+- Added support for the pgvector extension 
+- Added Read Only mode for connection

devart_postgresql_connector-1.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+devart/postgresql/__init__.py,sha256=qVu0auvx8Jb3xhYAuceQwzRozweiHAwdkvHXpr_d6Jo,969
+devart/postgresql/postgresql.cp313-win_amd64.pyd,sha256=VCMLJpsJFeptS_iSkvnTMGtStnURVqm-9pEZp-2E3C0,1095328
+devart/postgresql/postgresql.pyi,sha256=siUkOQO84--DMMEy7dZvnuJzIkp7UehEJPErcZaZIU0,12770
+devart/postgresql/http/tunnel.php,sha256=qjhBbshLEKSmoA7RAXVi29TbVNsPBad364d2YHsbyNQ,20720
+devart/postgresql/sqlalchemy/__init__.py,sha256=9T8yOdqr93tCiO3_79gBcO978mycjTt4STwuY8Kvv1g,525
+devart_postgresql_connector-1.2.0.dist-info/LICENSE,sha256=3sjizf07RF-z3Lp3tnA-jy3rN103Ypw11NO9tFnRLtU,8559
+devart_postgresql_connector-1.2.0.dist-info/METADATA,sha256=hwz8Ay3uRUorv1GTNIWprSarzCjNwfwwpCpfbP61-pk,2895
+devart_postgresql_connector-1.2.0.dist-info/WHEEL,sha256=YY3whN5zaIpzxWCxMHGQtwoICDXEsGAh-bKATaD2hj4,101
+devart_postgresql_connector-1.2.0.dist-info/top_level.txt,sha256=h_mZcghGiX6pnc-Kb1EoAfIW2iHeDA0kJKfcLJMbq44,7
+devart_postgresql_connector-1.2.0.dist-info/RECORD,,

devart_postgresql_connector-1.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

devart_postgresql_connector-1.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devart