feat(cli): refactor CLI entry point and synchronize WHOIS server list

XternalSoft · XternalSoft · commit 929537998134 · 2026-04-03T23:54:28.000+02:00
- Refactor bin/php-whois.php with improved autoload detection and type safety.
- Enhance CLI argument handling and add a --file option for local file parsing.
- Update module.tld.servers.json with latest IANA WHOIS server data.
- Add bin/update-whois-servers.php to automate future synchronization from IANA.

BREAKING CHANGE: CLI output and error handling in bin/php-whois.php have been
standardized, and the recommended execution path in help text has been updated.
diff --git a/bin/php-whois.php b/bin/php-whois.php
@@ -4,32 +4,58 @@
 
 use Xternalsoft\Whois\Factory;
 
-$scriptDir = '.';
-if (preg_match('~^(.+?)/[^/]+$~ui', $_SERVER['SCRIPT_FILENAME'], $m)) {
-    $scriptDir = $m[1];
+// Better autoload detection
+$autoloadFiles = [
+    __DIR__ . '/../vendor/autoload.php',
+    __DIR__ . '/../../../vendor/autoload.php',
+];
+
+$autoloadFile = null;
+foreach ($autoloadFiles as $file) {
+    if (file_exists($file)) {
+        $autoloadFile = $file;
+        break;
+    }
+}
+
+if (!$autoloadFile) {
+    die("Error: vendor/autoload.php not found. Please run 'composer install'.\n");
 }
-include "$scriptDir/../vendor/autoload.php";
 
-function main($argv)
+require_once $autoloadFile;
+
+function main(array $argv): void
 {
     $action = trim($argv[1] ?? '');
     $args = array_slice($argv, 2);
 
     if (empty($action)) {
         $action = 'help';
     }
-    switch (mb_strtolower(ltrim($action, '-'))) {
-        case 'help':
-        case 'h':
-            help();
-            return;
+
+    $actionLower = mb_strtolower(ltrim($action, '-'));
+    
+    if ($actionLower === 'help' || $actionLower === 'h') {
+        help();
+        return;
     }
+
     switch ($action) {
         case 'lookup':
+            if (empty($args[0])) {
+                echo "Error: domain argument is required for lookup.\n";
+                help();
+                exit(1);
+            }
             lookup($args[0]);
             break;
 
         case 'info':
+            if (empty($args[0])) {
+                echo "Error: domain argument is required for info.\n";
+                help();
+                exit(1);
+            }
             $opts = parseOpts(implode(' ', array_slice($args, 1)));
             info($args[0], $opts);
             break;
@@ -51,109 +77,117 @@ function parseOpts(string $str): array
     return $result;
 }
 
-function help()
+function help(): void
 {
     echo implode("\n", [
         'Welcome to php-whois CLI',
         '',
         '  Syntax:',
-        '    php-whois {action} [arg1 arg2 ... argN]',
-        '    php-whois help|--help|-h',
-        '    php-whois lookup {domain}',
-        '    php-whois info {domain} [--parser {type}] [--host {whois}]',
+        '    php bin/php-whois.php {action} [arg1 arg2 ... argN]',
+        '    php bin/php-whois.php help|--help|-h',
+        '    php bin/php-whois.php lookup {domain}',
+        '    php bin/php-whois.php info {domain} [--parser {type}] [--host {whois}] [--file {path}]',
         '',
         '  Examples',
-        '    php-whois lookup google.com',
-        '    php-whois info google.com',
-        '    php-whois info google.com --parser block',
-        '    php-whois info ya.ru --host whois.nic.ru --parser auto',
+        '    php bin/php-whois.php lookup google.com',
+        '    php bin/php-whois.php info google.com',
+        '    php bin/php-whois.php info google.com --parser block',
+        '    php bin/php-whois.php info ya.ru --host whois.nic.ru --parser auto',
         '',
-        '',
-    ]);
+    ]) . "\n";
 }
 
-function lookup(string $domain)
+function lookup(string $domain): void
 {
-    echo implode("\n", [
-        '  action: lookup',
-        "  domain: '{$domain}'",
-        '',
-        '',
-    ]);
+    echo "Action: lookup\n";
+    echo "Domain: '{$domain}'\n\n";
 
     $whois = Factory::get()->createWhois();
     $result = $whois->lookupDomain($domain);
 
     var_dump($result);
 }
 
-function info(string $domain, array $options = [])
+function info(string $domain, array $options = []): void
 {
     $options = array_replace([
         'host' => null,
         'parser' => null,
         'file' => null,
     ], $options);
 
-    echo implode("\n", [
-        '  action: info',
-        "  domain: '{$domain}'",
-        sprintf("  options: %s", json_encode($options, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)),
-        '',
-        '',
-    ]);
+    echo "Action: info\n";
+    echo "Domain: '{$domain}'\n";
+    echo sprintf("Options: %s\n\n", json_encode($options, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
 
     $loader = null;
     if ($options['file']) {
-        $loader = new \Xternalsoft\Whois\Loaders\FakeSocketLoader();
-        $loader->text = file_get_contents($options['file']);
+        if (!file_exists($options['file'])) {
+            die("Error: File not found: {$options['file']}\n");
+        }
+        
+        // Use a generic mock loader if FakeSocketLoader is not available (likely in non-dev env)
+        if (class_exists('\\Xternalsoft\\Whois\\Loaders\\FakeSocketLoader')) {
+            $loader = new \Xternalsoft\Whois\Loaders\FakeSocketLoader();
+            $loader->text = file_get_contents($options['file']);
+        } else {
+            // Simple anonymous class implementation of ILoader if available
+            echo "Warning: FakeSocketLoader not found, using raw file content bypass.\n";
+            // We can't easily mock ILoader here without knowing its interface fully 
+            // but we can try to use it if it exists or fallback.
+            // Actually, let's stick to the existing logic but add a check.
+            die("Error: --file option requires dev dependencies (FakeSocketLoader).\n");
+        }
     }
 
-    $tld = Factory::get()->createWhois($loader)->getTldModule();
-    $servers = $tld->matchServers($domain);
+    $factory = Factory::get();
+    $whois = $factory->createWhois($loader);
+    $tldModule = $factory->createTldModule($whois);
+    $servers = $tldModule->matchServers($domain);
 
     if (!empty($options['host'])) {
         $host = $options['host'];
-        $filteredServers = array_filter($servers, function (\Xternalsoft\Whois\Modules\Tld\TldServer $server) use ($host) {
-            return $server->getHost() == $host;
+        $filteredServers = array_filter($servers, function ($server) use ($host) {
+            return $server->getHost() === $host;
         });
-        if (count($filteredServers) == 0 && count($servers) > 0) {
-            $filteredServers = [$servers[0]];
-        }
-        $servers = array_map(function (\Xternalsoft\Whois\Modules\Tld\TldServer $server) use ($host) {
-            return new \Xternalsoft\Whois\Modules\Tld\TldServer(
-                $server->getZone(),
+        
+        if (count($filteredServers) === 0 && count($servers) > 0) {
+            // If the specific host isn't in matched servers, we take the first matched zone 
+            // but override the host
+            $baseServer = $servers[0];
+            $servers = [new \Xternalsoft\Whois\Modules\Tld\TldServer(
+                $baseServer->getZone(),
                 $host,
-                $server->isCentralized(),
-                $server->getParser(),
-                $server->getQueryFormat()
-            );
-        }, $filteredServers);
+                $baseServer->isCentralized(),
+                $baseServer->getParser(),
+                $baseServer->getQueryFormat()
+            )];
+        } else {
+            $servers = array_values($filteredServers);
+        }
     }
 
     if (!empty($options['parser'])) {
         try {
-            $parser = Factory::get()->createTldParser($options['parser']);
+            $parser = $factory->createTldParser($options['parser']);
         } catch (\Throwable $e) {
-            echo "\nCannot create TLD parser with type '{$options['parser']}'\n\n";
-            throw $e;
+            die("\nError: Cannot create TLD parser with type '{$options['parser']}'\n");
         }
-        $servers = array_map(function (\Xternalsoft\Whois\Modules\Tld\TldServer $server) use ($parser) {
-            return new \Xternalsoft\Whois\Modules\Tld\TldServer(
+        
+        foreach ($servers as $index => $server) {
+            $servers[$index] = new \Xternalsoft\Whois\Modules\Tld\TldServer(
                 $server->getZone(),
                 $server->getHost(),
                 $server->isCentralized(),
                 $parser,
                 $server->getQueryFormat()
             );
-        }, $servers);
+        }
     }
 
-    [, $info] = $tld->loadDomainData($domain, $servers);
+    $info = $tldModule->loadDomainData($domain, $servers);
 
     var_dump($info);
 }
 
 main($argv);
-
-
diff --git a/bin/update-whois-servers.php b/bin/update-whois-servers.php
@@ -0,0 +1,156 @@
+<?php
+
+/**
+ * WHOIS Server Configuration Updater
+ * 
+ * This script synchronizes the local TLD WHOIS server configuration with the official 
+ * IANA Root Database. It performs the following actions:
+ * 1. Downloads the latest TLD list from IANA.
+ * 2. Queries whois.iana.org for each TLD to identify the official WHOIS server.
+ * 3. Updates existing entries, adds missing TLDs, and removes decommissioned ones.
+ * 4. Preserves custom local configurations (like parserType or queryFormat).
+ * 
+ * Performance & Safety:
+ * - Implements a 1.5-second delay between requests to respect IANA rate limits.
+ * - Saves progress in a temporary JSON file to allow resuming after interruption.
+ * 
+ * Usage: php bin/update-whois-servers.php
+ */
+
+$configFile = __DIR__ . '/../src/Xternalsoft/Whois/Configs/module.tld.servers.json';
+$progressFile = __DIR__ . '/.iana_update_progress.json';
+
+if (!file_exists($configFile)) {
+    die("Error: Configuration file not found at $configFile\n");
+}
+
+// Load previous state or initialize new session
+if (file_exists($progressFile)) {
+    echo "Resuming from previous progress...\n";
+    $state = json_decode(file_get_contents($progressFile), true);
+    $indexed = $state['indexed'];
+    $processedZones = $state['processed'];
+} else {
+    $config = json_decode(file_get_contents($configFile), true);
+    $indexed = [];
+    foreach ($config as $entry) {
+        $zone = $entry['zone'];
+        if (!isset($indexed[$zone])) {
+            $indexed[$zone] = [];
+        }
+        $indexed[$zone][] = $entry;
+    }
+    $processedZones = [];
+}
+
+echo "Downloading TLD list from IANA...\n";
+$tldsList = @file_get_contents('https://data.iana.org/TLD/tlds-alpha-by-domain.txt');
+if (!$tldsList) {
+    die("Error: Unable to fetch TLD list from IANA.\n");
+}
+
+$tlds = array_filter(explode("\n", $tldsList), function($line) {
+    return $line && $line[0] !== '#';
+});
+
+$totalTlds = count($tlds);
+echo "Processing $totalTlds TLDs...\n";
+
+$updatedCount = 0;
+$addedCount = 0;
+$removedCount = 0;
+
+$count = 0;
+foreach ($tlds as $tld) {
+    $count++;
+    $tld = strtolower(trim($tld));
+    $zone = "." . $tld;
+    
+    // Skip if already processed in this session
+    if (in_array($zone, $processedZones)) {
+        continue;
+    }
+
+    echo "[$count/$totalTlds] Checking $zone... ";
+    
+    // Query IANA
+    $output = shell_exec("whois -h whois.iana.org " . escapeshellarg($zone));
+    
+    if (!$output) {
+        echo "ERROR (No response)\n";
+        continue;
+    }
+
+    // Check if TLD is decommissioned
+    if (strpos($output, 'status:       FORMER') !== false || strpos($output, 'This query returned 0 objects') !== false) {
+        if (isset($indexed[$zone])) {
+            unset($indexed[$zone]);
+            echo "REMOVED (Decommissioned)\n";
+            $removedCount++;
+        } else {
+            echo "SKIPPED (Does not exist)\n";
+        }
+    } else {
+        $ianaWhois = null;
+        // Accurate regex to capture the whois host
+        if (preg_match('/^whois:\s+([a-z0-9\.-]+)$/im', $output, $matches)) {
+            $ianaWhois = trim($matches[1]);
+        }
+        
+        if ($ianaWhois) {
+            if (isset($indexed[$zone])) {
+                $changed = false;
+                foreach ($indexed[$zone] as &$entry) {
+                    if ($entry['host'] !== $ianaWhois) {
+                        $entry['host'] = $ianaWhois;
+                        $changed = true;
+                    }
+                }
+                if ($changed) {
+                    echo "UPDATED -> $ianaWhois\n";
+                    $updatedCount++;
+                } else {
+                    echo "OK (Up to date)\n";
+                }
+            } else {
+                // New TLD found
+                $indexed[$zone] = [["zone" => $zone, "host" => $ianaWhois]];
+                echo "ADDED -> $ianaWhois\n";
+                $addedCount++;
+            }
+        } else {
+            echo "NO WHOIS SERVER DEFINED\n";
+        }
+    }
+    
+    // Save progress after each TLD
+    $processedZones[] = $zone;
+    file_put_contents($progressFile, json_encode([
+        'indexed' => $indexed,
+        'processed' => $processedZones
+    ]));
+
+    // Polite delay to avoid rate limiting
+    usleep(1500000); 
+}
+
+// Finalize and rebuild sorted config
+$newConfig = [];
+ksort($indexed);
+foreach ($indexed as $zone => $zoneEntries) {
+    foreach ($zoneEntries as $entry) {
+        $newConfig[] = $entry;
+    }
+}
+
+file_put_contents($configFile, json_encode($newConfig, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES));
+
+// Clean up progress file on success
+if (file_exists($progressFile)) {
+    unlink($progressFile);
+}
+
+echo "\nDone!\n";
+echo "Updated: $updatedCount\n";
+echo "Added:   $addedCount\n";
+echo "Removed: $removedCount\n";
diff --git a/src/Xternalsoft/Whois/Configs/module.tld.servers.json b/src/Xternalsoft/Whois/Configs/module.tld.servers.json
