Add files using upload-large-folder tool

bin/api_call.py

@@ -0,0 +1,219 @@
+"""
+World-Level API Resilience Toolkit
+====================================
+Handles: IP blocks, timeouts, rate limits, SSL errors, connection drops
+
+Usage:
+  python api_call.py GET https://api.example.com/endpoint
+  python api_call.py POST https://api.example.com/data '{"key":"value"}'
+  python api_call.py GET https://api.example.com --proxy http://127.0.0.1:8080
+
+Features:
+  - Auto Retry with Exponential Backoff
+  - Random User-Agent Rotation
+  - Connection Timeout Handling
+  - Rate Limit Detection (429) with Auto-Wait
+  - SSL Error Bypass Option
+  - Proxy Support (for mitmproxy or any proxy)
+  - Detailed Error Diagnosis
+"""
+
+import sys
+import time
+import random
+import json
+import urllib.request
+import urllib.error
+import urllib.parse
+import ssl
+import os
+
+# ─────────────────────────────────────────────
+# CONFIGURATION - Edit these as needed
+# ─────────────────────────────────────────────
+MAX_RETRIES = 5
+INITIAL_WAIT = 2       # seconds before first retry
+TIMEOUT = 30           # request timeout in seconds
+BYPASS_SSL = False     # Set True if getting SSL errors (self-signed certs)
+PROXY = None           # e.g. "http://127.0.0.1:8080" for mitmproxy
+# ─────────────────────────────────────────────
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/122.0 Safari/537.36",
+    "python-httpx/0.27.0",
+    "axios/1.7.2",
+    "curl/8.7.1",
+]
+
+DIAGNOSABLE_ERRORS = {
+    400: "BAD REQUEST - Check your payload/params format",
+    401: "UNAUTHORIZED - Check your API key/token",
+    403: "FORBIDDEN - IP may be blocked or permissions missing",
+    404: "NOT FOUND - Check the URL/endpoint",
+    408: "REQUEST TIMEOUT - Server too slow, try increasing TIMEOUT",
+    429: "RATE LIMITED - Waiting before retry...",
+    500: "SERVER ERROR - Their problem, will retry",
+    502: "BAD GATEWAY - Proxy/CDN issue, retrying",
+    503: "SERVICE UNAVAILABLE - Server overloaded, retrying",
+    504: "GATEWAY TIMEOUT - Network issue, retrying",
+}
+
+
+def make_request(method, url, data=None, headers=None, proxy=None, bypass_ssl=False, timeout=30):
+    """Core request function with all resilience features."""
+    if headers is None:
+        headers = {}
+
+    headers["User-Agent"] = random.choice(USER_AGENTS)
+    headers["Accept"] = "application/json, text/plain, */*"
+    headers["Accept-Language"] = "en-US,en;q=0.9"
+    headers["Connection"] = "keep-alive"
+
+    # SSL context
+    ctx = ssl.create_default_context()
+    if bypass_ssl:
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+    # Proxy handler
+    handlers = []
+    if proxy:
+        proxy_handler = urllib.request.ProxyHandler({"http": proxy, "https": proxy})
+        handlers.append(proxy_handler)
+
+    https_handler = urllib.request.HTTPSHandler(context=ctx)
+    handlers.append(https_handler)
+    opener = urllib.request.build_opener(*handlers)
+
+    # Build request
+    body = None
+    if data:
+        if isinstance(data, dict):
+            body = json.dumps(data).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        else:
+            body = data.encode("utf-8") if isinstance(data, str) else data
+
+    req = urllib.request.Request(url, data=body, headers=headers, method=method.upper())
+
+    response = opener.open(req, timeout=timeout)
+    raw = response.read()
+    status = response.status
+
+    try:
+        result = json.loads(raw)
+    except Exception:
+        result = raw.decode("utf-8", errors="replace")
+
+    return status, result
+
+
+def api_call(method, url, data=None, headers=None):
+    """Resilient API call with retry, backoff, and diagnosis."""
+    wait = INITIAL_WAIT
+    last_error = None
+
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            print(f"\n[Attempt {attempt}/{MAX_RETRIES}] {method.upper()} {url}")
+            status, result = make_request(
+                method, url, data=data, headers=headers,
+                proxy=PROXY, bypass_ssl=BYPASS_SSL, timeout=TIMEOUT
+            )
+
+            if status == 429:
+                retry_after = wait * 3
+                print(f"  âš  {DIAGNOSABLE_ERRORS[429]}")
+                print(f"  Waiting {retry_after}s before next attempt...")
+                time.sleep(retry_after)
+                wait = min(wait * 2, 120)
+                continue
+
+            if 200 <= status < 300:
+                print(f"  ✓ SUCCESS ({status})")
+                return status, result
+
+            msg = DIAGNOSABLE_ERRORS.get(status, f"HTTP {status} - Unexpected error")
+            print(f"  ✗ {msg}")
+
+            if status in (400, 401, 403, 404):
+                print("  → Non-retryable error. Stopping.")
+                return status, result
+
+        except urllib.error.URLError as e:
+            reason = str(e.reason)
+            print(f"  ✗ CONNECTION ERROR: {reason}")
+
+            if "SSL" in reason or "certificate" in reason.lower():
+                print("  DIAGNOSIS: SSL/Certificate issue.")
+                print("  FIX: Set BYPASS_SSL = True in this script")
+            elif "timed out" in reason.lower():
+                print("  DIAGNOSIS: Connection timed out.")
+                print("  FIX: Increase TIMEOUT or check network")
+            elif "Name or service not known" in reason or "getaddrinfo" in reason:
+                print("  DIAGNOSIS: DNS resolution failed.")
+                print("  FIX: Check internet / try a different DNS (1.1.1.1)")
+            else:
+                print("  DIAGNOSIS: Network/connectivity issue.")
+                print("  FIX: Try mitmproxy or a proxy for routing")
+
+            last_error = e
+
+        except TimeoutError:
+            print(f"  ✗ TIMEOUT after {TIMEOUT}s")
+            last_error = "Timeout"
+
+        except Exception as e:
+            print(f"  ✗ UNEXPECTED: {e}")
+            last_error = e
+
+        if attempt < MAX_RETRIES:
+            print(f"  ↻ Retrying in {wait}s... (backoff)")
+            time.sleep(wait)
+            wait = min(wait * 2, 60)
+
+    print(f"\n✗ All {MAX_RETRIES} attempts failed. Last error: {last_error}")
+    return None, None
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python api_call.py <METHOD> <URL> [JSON_BODY] [--proxy PROXY_URL]")
+        print("Examples:")
+        print("  python api_call.py GET https://httpbin.org/get")
+        print("  python api_call.py POST https://httpbin.org/post '{\"key\":\"value\"}'")
+        print("  python api_call.py GET https://api.github.com/repos/cli/cli --proxy http://127.0.0.1:8080")
+        sys.exit(1)
+
+    method = sys.argv[1]
+    url = sys.argv[2]
+    data = None
+    global PROXY
+
+    args = sys.argv[3:]
+    for i, arg in enumerate(args):
+        if arg == "--proxy" and i + 1 < len(args):
+            PROXY = args[i + 1]
+        elif arg.startswith("{") or arg.startswith("["):
+            try:
+                data = json.loads(arg)
+            except Exception:
+                data = arg
+
+    status, result = api_call(method, url, data=data)
+
+    if result is not None:
+        print("\n─── RESPONSE ─────────────────────────────")
+        if isinstance(result, (dict, list)):
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(result)
+        print("─────────────────────────────────────────")
+
+
+if __name__ == "__main__":
+    main()
+

bin/big_file_sender.py

@@ -0,0 +1,78 @@
+"""
+Big File Streamer (Anti-Block Uploader)
+=======================================
+This script uploads MASSIVE files (10GB+) to APIs without crashing your RAM
+or getting blocked by Windows Network limits. It streams the file directly
+from the Hard Drive to the Network.
+
+Usage:
+  python bin\big_file_sender.py https://api.example.com/upload my_huge_model.bin
+  python bin\big_file_sender.py https://api.example.com/upload data.zip --token "YOUR_API_KEY"
+"""
+
+import sys
+import argparse
+import requests
+import os
+from tqdm import tqdm
+
+def upload_huge_file(url, file_path, token=None):
+    if not os.path.exists(file_path):
+        print(f"[ERROR] File not found: {file_path}")
+        return
+
+    file_size = os.path.getsize(file_path)
+    file_name = os.path.basename(file_path)
+    
+    print(f"[INFO] Preparing to stream: {file_name} ({file_size / (1024*1024):.2f} MB)")
+    print(f"[INFO] Target API: {url}")
+    
+    headers = {
+        "Content-Type": "application/octet-stream",
+        "Content-Disposition": f'attachment; filename="{file_name}"',
+        # Keep connection alive so Windows doesn't drop it
+        "Connection": "keep-alive" 
+    }
+    
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    # Create a streaming generator to read the file in chunks of 8MB
+    # This prevents Windows RAM overload and bypasses strict buffer limits
+    def file_stream_generator(filepath, chunk_size=8192*1024):
+        with open(filepath, 'rb') as f:
+            with tqdm(total=file_size, unit='B', unit_scale=True, desc="Uploading") as pbar:
+                while True:
+                    chunk = f.read(chunk_size)
+                    if not chunk:
+                        break
+                    yield chunk
+                    pbar.update(len(chunk))
+
+    try:
+        # requests will stream the generator directly to the network socket
+        response = requests.post(
+            url, 
+            data=file_stream_generator(file_path), 
+            headers=headers,
+            stream=True,
+            timeout=3600 # 1 hour timeout for huge files
+        )
+        
+        print("\n[SUCCESS] Upload Complete!")
+        print(f"Server Response ({response.status_code}): {response.text}")
+        
+    except requests.exceptions.ConnectionError:
+        print("\n[ERROR] Connection Dropped by Target Server or Windows Firewall.")
+        print("Tip: If it keeps dropping, use the 'rclone' tool provided in your bin folder.")
+    except Exception as e:
+        print(f"\n[ERROR] Upload Failed: {e}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Upload huge files via streaming.")
+    parser.add_argument("url", help="The API Endpoint URL")
+    parser.add_argument("file", help="Path to the large file")
+    parser.add_argument("--token", help="Optional Bearer API Token", default=None)
+    
+    args = parser.parse_args()
+    upload_huge_file(args.url, args.file, args.token)

bin/msbuild.bat

@@ -0,0 +1,2 @@
+@echo off
+dotnet msbuild %*

bin/rag_system.py

@@ -0,0 +1,174 @@
+"""
+Portable RAG (Retrieval-Augmented Generation) System
+=====================================================
+A completely portable, offline-capable RAG setup using ChromaDB and FastEmbed.
+
+Usage:
+  1. Add a Document:
+     python rag_system.py ingest my_document.pdf
+     python rag_system.py ingest my_notes.txt
+
+  2. Query the Knowledge Base:
+     python rag_system.py query "What is the main topic?"
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+
+# Fix for ChromaDB SQLite requirement in some environments
+import sqlite3
+import chromadb
+
+# LangChain components
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+
+# HuggingFace for Embeddings ^& LLM Generation
+from langchain_huggingface import HuggingFaceEndpoint, HuggingFaceEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.output_parsers import StrOutputParser
+
+# Configuration
+DEVTOOLS_ROOT = Path(os.environ.get("DEVTOOLS_ROOT", os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+RAG_DATA_DIR = DEVTOOLS_ROOT / "rag_data"
+RAG_DATA_DIR.mkdir(exist_ok=True)
+
+
+# 1. Initialize Embeddings (LOCAL - No Token Needed)
+print("[INFO] Loading Embedding Model (Local - This may take a moment on first run)...")
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2",
+    model_kwargs={'device': 'cpu'}
+)
+
+# 2. Initialize Chroma Vector Database
+print(f"[INFO] Connecting to ChromaDB at {RAG_DATA_DIR}...")
+vectorstore = Chroma(
+    embedding_function=embeddings,
+    persist_directory=str(RAG_DATA_DIR)
+)
+
+
+def ingest_document(file_path: str):
+    """Reads a file, splits it into chunks, and saves to Vector DB."""
+    path = Path(file_path)
+    if not path.exists():
+        print(f"[ERROR] File not found: {file_path}")
+        sys.exit(1)
+
+    print(f"\n[1/3] Loading document: {path.name}...")
+    if path.suffix.lower() == '.pdf':
+        loader = PyPDFLoader(str(path))
+    elif path.suffix.lower() == '.txt':
+        loader = TextLoader(str(path), encoding='utf-8')
+    else:
+        print("[ERROR] Unsupported file type. Please use .pdf or .txt")
+        sys.exit(1)
+
+    docs = loader.load()
+    print(f"      Loaded {len(docs)} pages/sections.")
+
+    print("[2/3] Splitting into chunks...")
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    splits = text_splitter.split_documents(docs)
+    print(f"      Created {len(splits)} chunks.")
+
+    print("[3/3] Generating vectors and saving to database...")
+    vectorstore.add_documents(splits)
+    print("\n[SUCCESS] Document ingested successfully!")
+
+
+def format_docs(docs):
+    return "\n\n".join(doc.page_content for doc in docs)
+
+
+def query_rag(query: str):
+    """Retrieves relevant chunks and optionally uses an LLM to generate an answer."""
+    print(f"\n[Q] {query}\n")
+
+    # Step 1: Retrieval
+    print("─── RETRIEVED CONTEXT ────────────────────")
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+    results = retriever.invoke(query)
+    
+    if not results:
+        print("No relevant context found in the database.")
+        return
+
+    for i, doc in enumerate(results):
+        source = doc.metadata.get('source', 'Unknown')
+        page = doc.metadata.get('page', '')
+        page_info = f" (Page {page})" if page else ""
+        print(f"[{i+1}] Source: {os.path.basename(source)}{page_info}")
+        print(f"    {doc.page_content[:300]}...\n")
+
+    # Step 2: Generation (Optional - Requires Token)
+    hf_token = os.environ.get("HF_TOKEN")
+    if hf_token:
+        print("\n─── AI GENERATED ANSWER ──────────────────")
+        try:
+            llm = HuggingFaceEndpoint(
+                repo_id="meta-llama/Meta-Llama-3-8B-Instruct",
+                task="text-generation",
+                max_new_tokens=512,
+                huggingfacehub_api_token=hf_token
+            )
+            
+            template = """You are an assistant for question-answering tasks. 
+Use the following pieces of retrieved context to answer the question. 
+If you don't know the answer, say that you don't know. 
+Keep the answer concise and accurate based ONLY on the context.
+
+Context: {context}
+
+Question: {question}
+
+Answer:"""
+            prompt = ChatPromptTemplate.from_template(template)
+            
+            rag_chain = (
+                {"context": retriever | format_docs, "question": RunnablePassthrough()}
+                | prompt
+                | llm
+                | StrOutputParser()
+            )
+            
+            response = rag_chain.invoke(query)
+            print(response.strip())
+            
+        except Exception as e:
+            print(f"[WARN] Could not generate AI answer. (Are you logged into Hugging Face?)")
+            print(f"       Error: {e}")
+    else:
+        print("\n[NOTE] HuggingFace token not found. Only returning retrieved documents.")
+        print("       Run 'hf auth login' in your terminal to enable AI Generation.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Portable RAG System")
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # Ingest command
+    ingest_parser = subparsers.add_parser("ingest", help="Ingest a document into the database")
+    ingest_parser.add_argument("file", type=str, help="Path to PDF or TXT file")
+
+    # Query command
+    query_parser = subparsers.add_parser("query", help="Query the database")
+    query_parser.add_argument("query", type=str, help="Your question")
+
+    args = parser.parse_args()
+
+    if args.command == "ingest":
+        ingest_document(args.file)
+    elif args.command == "query":
+        query_rag(args.query)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

cuda_toolkit/version.json

@@ -0,0 +1,118 @@
+{
+   "cuda" : {
+      "name" : "CUDA SDK",
+      "version" : "12.4.1"
+   },
+   "cuda_cccl" : {
+      "name" : "CUDA C++ Core Compute Libraries",
+      "version" : "12.4.127"
+   },
+   "cuda_cudart" : {
+      "name" : "CUDA Runtime (cudart)",
+      "version" : "12.4.127"
+   },
+   "cuda_cuobjdump" : {
+      "name" : "cuobjdump",
+      "version" : "12.4.127"
+   },
+   "cuda_cupti" : {
+      "name" : "CUPTI",
+      "version" : "12.4.127"
+   },
+   "cuda_cuxxfilt" : {
+      "name" : "CUDA cu++ filt",
+      "version" : "12.4.127"
+   },
+   "cuda_demo_suite" : {
+      "name" : "CUDA Demo Suite",
+      "version" : "12.4.127"
+   },
+   "cuda_nvcc" : {
+      "name" : "CUDA NVCC",
+      "version" : "12.4.131"
+   },
+   "cuda_nvdisasm" : {
+      "name" : "CUDA nvdisasm",
+      "version" : "12.4.127"
+   },
+   "cuda_nvml_dev" : {
+      "name" : "CUDA NVML Headers",
+      "version" : "12.4.127"
+   },
+   "cuda_nvprof" : {
+      "name" : "CUDA nvprof",
+      "version" : "12.4.127"
+   },
+   "cuda_nvprune" : {
+      "name" : "CUDA nvprune",
+      "version" : "12.4.127"
+   },
+   "cuda_nvrtc" : {
+      "name" : "CUDA NVRTC",
+      "version" : "12.4.127"
+   },
+   "cuda_nvtx" : {
+      "name" : "CUDA NVTX",
+      "version" : "12.4.127"
+   },
+   "cuda_nvvp" : {
+      "name" : "CUDA NVVP",
+      "version" : "12.4.127"
+   },
+   "cuda_opencl" : {
+      "name" : "CUDA OpenCL",
+      "version" : "12.4.127"
+   },
+   "cuda_sanitizer_api" : {
+      "name" : "CUDA Compute Sanitizer API",
+      "version" : "12.4.127"
+   },
+   "libcublas" : {
+      "name" : "CUDA cuBLAS",
+      "version" : "12.4.5.8"
+   },
+   "libcufft" : {
+      "name" : "CUDA cuFFT",
+      "version" : "11.2.1.3"
+   },
+   "libcurand" : {
+      "name" : "CUDA cuRAND",
+      "version" : "10.3.5.147"
+   },
+   "libcusolver" : {
+      "name" : "CUDA cuSOLVER",
+      "version" : "11.6.1.9"
+   },
+   "libcusparse" : {
+      "name" : "CUDA cuSPARSE",
+      "version" : "12.3.1.170"
+   },
+   "libnpp" : {
+      "name" : "CUDA NPP",
+      "version" : "12.2.5.30"
+   },
+   "libnvfatbin" : {
+      "name" : "Fatbin interaction library",
+      "version" : "12.4.127"
+   },
+   "libnvjitlink" : {
+      "name" : "JIT Linker Library",
+      "version" : "12.4.127"
+   },
+   "libnvjpeg" : {
+      "name" : "CUDA nvJPEG",
+      "version" : "12.3.1.117"
+   },
+   "nsight_compute" : {
+      "name" : "Nsight Compute",
+      "version" : "2024.1.1.4"
+   },
+   "nsight_vse" : {
+      "name" : "Nsight Visual Studio Edition (VSE)",
+      "version" : "2024.1.1.24072"
+   },
+   "nvidia_driver" : {
+      "name" : "NVIDIA Windows Driver",
+      "version" : "551.78"
+   }
+}

git/usr/share/perl5/core_perl/I18N/LangTags.pm

@@ -0,0 +1,887 @@
+
+# Time-stamp: "2004-10-06 23:26:33 ADT"
+# Sean M. Burke <sburke@cpan.org>
+
+require 5.000;
+package I18N::LangTags;
+use strict;
+require Exporter;
+our @ISA = qw(Exporter);
+our @EXPORT = qw();
+our @EXPORT_OK = qw(is_language_tag same_language_tag
+                extract_language_tags super_languages
+                similarity_language_tag is_dialect_of
+                locale2language_tag alternate_language_tags
+                encode_language_tag panic_languages
+                implicate_supers
+                implicate_supers_strictly
+               );
+our %EXPORT_TAGS = ('ALL' => \@EXPORT_OK);
+
+our $VERSION = "0.45";
+our %Panic;
+
+sub uniq { my %seen; return grep(!($seen{$_}++), @_); } # a util function
+
+
+=head1 NAME
+
+I18N::LangTags - functions for dealing with RFC3066-style language tags
+
+=head1 SYNOPSIS
+
+  use I18N::LangTags();
+
+...or specify whichever of those functions you want to import, like so:
+
+  use I18N::LangTags qw(implicate_supers similarity_language_tag);
+
+All the exportable functions are listed below -- you're free to import
+only some, or none at all.  By default, none are imported.  If you
+say:
+
+    use I18N::LangTags qw(:ALL)
+
+...then all are exported.  (This saves you from having to use
+something less obvious like C<use I18N::LangTags qw(/./)>.)
+
+If you don't import any of these functions, assume a C<&I18N::LangTags::>
+in front of all the function names in the following examples.
+
+=head1 DESCRIPTION
+
+Language tags are a formalism, described in RFC 3066 (obsoleting
+1766), for declaring what language form (language and possibly
+dialect) a given chunk of information is in.
+
+This library provides functions for common tasks involving language
+tags as they are needed in a variety of protocols and applications.
+
+Please see the "See Also" references for a thorough explanation
+of how to correctly use language tags.
+
+=over
+
+=cut
+
+###########################################################################
+
+=item * the function is_language_tag($lang1)
+
+Returns true iff $lang1 is a formally valid language tag.
+
+   is_language_tag("fr")            is TRUE
+   is_language_tag("x-jicarilla")   is FALSE
+       (Subtags can be 8 chars long at most -- 'jicarilla' is 9)
+
+   is_language_tag("sgn-US")    is TRUE
+       (That's American Sign Language)
+
+   is_language_tag("i-Klikitat")    is TRUE
+       (True without regard to the fact noone has actually
+        registered Klikitat -- it's a formally valid tag)
+
+   is_language_tag("fr-patois")     is TRUE
+       (Formally valid -- altho descriptively weak!)
+
+   is_language_tag("Spanish")       is FALSE
+   is_language_tag("french-patois") is FALSE
+       (No good -- first subtag has to match
+        /^([xXiI]|[a-zA-Z]{2,3})$/ -- see RFC3066)
+
+   is_language_tag("x-borg-prot2532") is TRUE
+       (Yes, subtags can contain digits, as of RFC3066)
+
+=cut
+
+sub is_language_tag {
+
+  ## Changes in the language tagging standards may have to be reflected here.
+
+  my($tag) = lc($_[0]);
+
+  return 0 if $tag eq "i" or $tag eq "x";
+  # Bad degenerate cases that the following
+  #  regexp would erroneously let pass
+
+  return $tag =~ 
+    /^(?:  # First subtag
+         [xi] | [a-z]{2,3}
+      )
+      (?:  # Subtags thereafter
+         -           # separator
+         [a-z0-9]{1,8}  # subtag  
+      )*
+    $/xs ? 1 : 0;
+}
+
+###########################################################################
+
+=item * the function extract_language_tags($whatever)
+
+Returns a list of whatever looks like formally valid language tags
+in $whatever.  Not very smart, so don't get too creative with
+what you want to feed it.
+
+  extract_language_tags("fr, fr-ca, i-mingo")
+    returns:   ('fr', 'fr-ca', 'i-mingo')
+
+  extract_language_tags("It's like this: I'm in fr -- French!")
+    returns:   ('It', 'in', 'fr')
+  (So don't just feed it any old thing.)
+
+The output is untainted.  If you don't know what tainting is,
+don't worry about it.
+
+=cut
+
+sub extract_language_tags {
+
+  ## Changes in the language tagging standards may have to be reflected here.
+
+  my($text) =
+    $_[0] =~ m/(.+)/  # to make for an untainted result
+    ? $1 : ''
+  ;
+  
+  return grep(!m/^[ixIX]$/s, # 'i' and 'x' aren't good tags
+    $text =~ 
+    m/
+      \b
+      (?:  # First subtag
+         [iIxX] | [a-zA-Z]{2,3}
+      )
+      (?:  # Subtags thereafter
+         -           # separator
+         [a-zA-Z0-9]{1,8}  # subtag  
+      )*
+      \b
+    /xsg
+  );
+}
+
+###########################################################################
+
+=item * the function same_language_tag($lang1, $lang2)
+
+Returns true iff $lang1 and $lang2 are acceptable variant tags
+representing the same language-form.
+
+   same_language_tag('x-kadara', 'i-kadara')  is TRUE
+      (The x/i- alternation doesn't matter)
+   same_language_tag('X-KADARA', 'i-kadara')  is TRUE
+      (...and neither does case)
+   same_language_tag('en',       'en-US')     is FALSE
+      (all-English is not the SAME as US English)
+   same_language_tag('x-kadara', 'x-kadar')   is FALSE
+      (these are totally unrelated tags)
+   same_language_tag('no-bok',    'nb')       is TRUE
+      (no-bok is a legacy tag for nb (Norwegian Bokmal))
+
+C<same_language_tag> works by just seeing whether
+C<encode_language_tag($lang1)> is the same as
+C<encode_language_tag($lang2)>.
+
+(Yes, I know this function is named a bit oddly.  Call it historic
+reasons.)
+
+=cut
+
+sub same_language_tag {
+  my $el1 = &encode_language_tag($_[0]);
+  return 0 unless defined $el1;
+   # this avoids the problem of
+   # encode_language_tag($lang1) eq and encode_language_tag($lang2)
+   # being true if $lang1 and $lang2 are both undef
+
+  return $el1 eq &encode_language_tag($_[1]) ? 1 : 0;
+}
+
+###########################################################################
+
+=item * the function similarity_language_tag($lang1, $lang2)
+
+Returns an integer representing the degree of similarity between
+tags $lang1 and $lang2 (the order of which does not matter), where
+similarity is the number of common elements on the left,
+without regard to case and to x/i- alternation.
+
+   similarity_language_tag('fr', 'fr-ca')           is 1
+      (one element in common)
+   similarity_language_tag('fr-ca', 'fr-FR')        is 1
+      (one element in common)
+
+   similarity_language_tag('fr-CA-joual',
+                           'fr-CA-PEI')             is 2
+   similarity_language_tag('fr-CA-joual', 'fr-CA')  is 2
+      (two elements in common)
+
+   similarity_language_tag('x-kadara', 'i-kadara')  is 1
+      (x/i- doesn't matter)
+
+   similarity_language_tag('en',       'x-kadar')   is 0
+   similarity_language_tag('x-kadara', 'x-kadar')   is 0
+      (unrelated tags -- no similarity)
+
+   similarity_language_tag('i-cree-syllabic',
+                           'i-cherokee-syllabic')   is 0
+      (no B<leftmost> elements in common!)
+
+=cut
+
+sub similarity_language_tag {
+  my $lang1 = &encode_language_tag($_[0]);
+  my $lang2 = &encode_language_tag($_[1]);
+   # And encode_language_tag takes care of the whole
+   #  no-nyn==nn, i-hakka==zh-hakka, etc, things
+   
+  # NB: (i-sil-...)?  (i-sgn-...)?
+
+  return undef if !defined($lang1) and !defined($lang2);
+  return 0 if !defined($lang1) or !defined($lang2);
+
+  my @l1_subtags = split('-', $lang1);
+  my @l2_subtags = split('-', $lang2);
+  my $similarity = 0;
+
+  while(@l1_subtags and @l2_subtags) {
+    if(shift(@l1_subtags) eq shift(@l2_subtags)) {
+      ++$similarity;
+    } else {
+      last;
+    } 
+  }
+  return $similarity;
+}
+
+###########################################################################
+
+=item * the function is_dialect_of($lang1, $lang2)
+
+Returns true iff language tag $lang1 represents a subform of
+language tag $lang2.
+
+B<Get the order right!  It doesn't work the other way around!>
+
+   is_dialect_of('en-US', 'en')            is TRUE
+     (American English IS a dialect of all-English)
+
+   is_dialect_of('fr-CA-joual', 'fr-CA')   is TRUE
+   is_dialect_of('fr-CA-joual', 'fr')      is TRUE
+     (Joual is a dialect of (a dialect of) French)
+
+   is_dialect_of('en', 'en-US')            is FALSE
+     (all-English is a NOT dialect of American English)
+
+   is_dialect_of('fr', 'en-CA')            is FALSE
+
+   is_dialect_of('en',    'en'   )         is TRUE
+   is_dialect_of('en-US', 'en-US')         is TRUE
+     (B<Note:> these are degenerate cases)
+
+   is_dialect_of('i-mingo-tom', 'x-Mingo') is TRUE
+     (the x/i thing doesn't matter, nor does case)
+
+   is_dialect_of('nn', 'no')               is TRUE
+     (because 'nn' (New Norse) is aliased to 'no-nyn',
+      as a special legacy case, and 'no-nyn' is a
+      subform of 'no' (Norwegian))
+
+=cut
+
+sub is_dialect_of {
+
+  my $lang1 = &encode_language_tag($_[0]);
+  my $lang2 = &encode_language_tag($_[1]);
+
+  return undef if !defined($lang1) and !defined($lang2);
+  return 0 if !defined($lang1) or !defined($lang2);
+
+  return 1 if $lang1 eq $lang2;
+  return 0 if length($lang1) < length($lang2);
+
+  $lang1 .= '-';
+  $lang2 .= '-';
+  return
+    (substr($lang1, 0, length($lang2)) eq $lang2) ? 1 : 0;
+}
+
+###########################################################################
+
+=item * the function super_languages($lang1)
+
+Returns a list of language tags that are superordinate tags to $lang1
+-- it gets this by removing subtags from the end of $lang1 until
+nothing (or just "i" or "x") is left.
+
+   super_languages("fr-CA-joual")  is  ("fr-CA", "fr")
+
+   super_languages("en-AU")  is  ("en")
+
+   super_languages("en")  is  empty-list, ()
+
+   super_languages("i-cherokee")  is  empty-list, ()
+    ...not ("i"), which would be illegal as well as pointless.
+
+If $lang1 is not a valid language tag, returns empty-list in
+a list context, undef in a scalar context.
+
+A notable and rather unavoidable problem with this method:
+"x-mingo-tom" has an "x" because the whole tag isn't an
+IANA-registered tag -- but super_languages('x-mingo-tom') is
+('x-mingo') -- which isn't really right, since 'i-mingo' is
+registered.  But this module has no way of knowing that.  (But note
+that same_language_tag('x-mingo', 'i-mingo') is TRUE.)
+
+More importantly, you assume I<at your peril> that superordinates of
+$lang1 are mutually intelligible with $lang1.  Consider this
+carefully.
+
+=cut 
+
+sub super_languages {
+  my $lang1 = $_[0];
+  return() unless defined($lang1) && &is_language_tag($lang1);
+
+  # a hack for those annoying new (2001) tags:
+  $lang1 =~ s/^nb\b/no-bok/i; # yes, backwards
+  $lang1 =~ s/^nn\b/no-nyn/i; # yes, backwards
+  $lang1 =~ s/^[ix](-hakka\b)/zh$1/i; # goes the right way
+   # i-hakka-bork-bjork-bjark => zh-hakka-bork-bjork-bjark
+
+  my @l1_subtags = split('-', $lang1);
+
+  ## Changes in the language tagging standards may have to be reflected here.
+
+  # NB: (i-sil-...)?
+
+  my @supers = ();
+  foreach my $bit (@l1_subtags) {
+    push @supers, 
+      scalar(@supers) ? ($supers[-1] . '-' . $bit) : $bit;
+  }
+  pop @supers if @supers;
+  shift @supers if @supers && $supers[0] =~ m<^[iIxX]$>s;
+  return reverse @supers;
+}
+
+###########################################################################
+
+=item * the function locale2language_tag($locale_identifier)
+
+This takes a locale name (like "en", "en_US", or "en_US.ISO8859-1")
+and maps it to a language tag.  If it's not mappable (as with,
+notably, "C" and "POSIX"), this returns empty-list in a list context,
+or undef in a scalar context.
+
+   locale2language_tag("en") is "en"
+
+   locale2language_tag("en_US") is "en-US"
+
+   locale2language_tag("en_US.ISO8859-1") is "en-US"
+
+   locale2language_tag("C") is undef or ()
+
+   locale2language_tag("POSIX") is undef or ()
+
+   locale2language_tag("POSIX") is undef or ()
+
+I'm not totally sure that locale names map satisfactorily to language
+tags.  Think REAL hard about how you use this.  YOU HAVE BEEN WARNED.
+
+The output is untainted.  If you don't know what tainting is,
+don't worry about it.
+
+=cut 
+
+sub locale2language_tag {
+  my $lang =
+    $_[0] =~ m/(.+)/  # to make for an untainted result
+    ? $1 : ''
+  ;
+
+  return $lang if &is_language_tag($lang); # like "en"
+
+  $lang =~ tr<_><->;  # "en_US" -> en-US
+  $lang =~ s<(?:[\.\@][-_a-zA-Z0-9]+)+$><>s;  # "en_US.ISO8859-1" -> en-US
+   # it_IT.utf8@euro => it-IT
+
+  return $lang if &is_language_tag($lang);
+
+  return;
+}
+
+###########################################################################
+
+=item * the function encode_language_tag($lang1)
+
+This function, if given a language tag, returns an encoding of it such
+that:
+
+* tags representing different languages never get the same encoding.
+
+* tags representing the same language always get the same encoding.
+
+* an encoding of a formally valid language tag always is a string
+value that is defined, has length, and is true if considered as a
+boolean.
+
+Note that the encoding itself is B<not> a formally valid language tag.
+Note also that you cannot, currently, go from an encoding back to a
+language tag that it's an encoding of.
+
+Note also that you B<must> consider the encoded value as atomic; i.e.,
+you should not consider it as anything but an opaque, unanalysable
+string value.  (The internals of the encoding method may change in
+future versions, as the language tagging standard changes over time.)
+
+C<encode_language_tag> returns undef if given anything other than a
+formally valid language tag.
+
+The reason C<encode_language_tag> exists is because different language
+tags may represent the same language; this is normally treatable with
+C<same_language_tag>, but consider this situation:
+
+You have a data file that expresses greetings in different languages.
+Its format is "[language tag]=[how to say 'Hello']", like:
+
+          en-US=Hiho
+          fr=Bonjour
+          i-mingo=Hau'
+
+And suppose you write a program that reads that file and then runs as
+a daemon, answering client requests that specify a language tag and
+then expect the string that says how to greet in that language.  So an
+interaction looks like:
+
+          greeting-client asks:    fr
+          greeting-server answers: Bonjour
+
+So far so good.  But suppose the way you're implementing this is:
+
+          my %greetings;
+          die unless open(IN, "<", "in.dat");
+          while(<IN>) {
+            chomp;
+            next unless /^([^=]+)=(.+)/s;
+            my($lang, $expr) = ($1, $2);
+            $greetings{$lang} = $expr;
+          }
+          close(IN);
+
+at which point %greetings has the contents:
+
+          "en-US"   => "Hiho"
+          "fr"      => "Bonjour"
+          "i-mingo" => "Hau'"
+
+And suppose then that you answer client requests for language $wanted
+by just looking up $greetings{$wanted}.
+
+If the client asks for "fr", that will look up successfully in
+%greetings, to the value "Bonjour".  And if the client asks for
+"i-mingo", that will look up successfully in %greetings, to the value
+"Hau'".
+
+But if the client asks for "i-Mingo" or "x-mingo", or "Fr", then the
+lookup in %greetings fails.  That's the Wrong Thing.
+
+You could instead do lookups on $wanted with:
+
+          use I18N::LangTags qw(same_language_tag);
+          my $response = '';
+          foreach my $l2 (keys %greetings) {
+            if(same_language_tag($wanted, $l2)) {
+              $response = $greetings{$l2};
+              last;
+            }
+          }
+
+But that's rather inefficient.  A better way to do it is to start your
+program with:
+
+          use I18N::LangTags qw(encode_language_tag);
+          my %greetings;
+          die unless open(IN, "<", "in.dat");
+          while(<IN>) {
+            chomp;
+            next unless /^([^=]+)=(.+)/s;
+            my($lang, $expr) = ($1, $2);
+            $greetings{
+                        encode_language_tag($lang)
+                      } = $expr;
+          }
+          close(IN);
+
+and then just answer client requests for language $wanted by just
+looking up
+
+          $greetings{encode_language_tag($wanted)}
+
+And that does the Right Thing.
+
+=cut
+
+sub encode_language_tag {
+  # Only similarity_language_tag() is allowed to analyse encodings!
+
+  ## Changes in the language tagging standards may have to be reflected here.
+
+  my($tag) = $_[0] || return undef;
+  return undef unless &is_language_tag($tag);
+
+  # For the moment, these legacy variances are few enough that
+  #  we can just handle them here with regexps.
+  $tag =~ s/^iw\b/he/i; # Hebrew
+  $tag =~ s/^in\b/id/i; # Indonesian
+  $tag =~ s/^cre\b/cr/i; # Cree
+  $tag =~ s/^jw\b/jv/i; # Javanese
+  $tag =~ s/^[ix]-lux\b/lb/i;  # Luxemburger
+  $tag =~ s/^[ix]-navajo\b/nv/i;  # Navajo
+  $tag =~ s/^ji\b/yi/i;  # Yiddish
+  # SMB 2003 -- Hm.  There's a bunch of new XXX->YY variances now,
+  #  but maybe they're all so obscure I can ignore them.   "Obscure"
+  #  meaning either that the language is obscure, and/or that the
+  #  XXX form was extant so briefly that it's unlikely it was ever
+  #  used.  I hope.
+  #
+  # These go FROM the simplex to complex form, to get
+  #  similarity-comparison right.  And that's okay, since
+  #  similarity_language_tag is the only thing that
+  #  analyzes our output.
+  $tag =~ s/^[ix]-hakka\b/zh-hakka/i;  # Hakka
+  $tag =~ s/^nb\b/no-bok/i;  # BACKWARDS for Bokmal
+  $tag =~ s/^nn\b/no-nyn/i;  # BACKWARDS for Nynorsk
+
+  $tag =~ s/^[xiXI]-//s;
+   # Just lop off any leading "x/i-"
+
+  return "~" . uc($tag);
+}
+
+#--------------------------------------------------------------------------
+
+=item * the function alternate_language_tags($lang1)
+
+This function, if given a language tag, returns all language tags that
+are alternate forms of this language tag.  (I.e., tags which refer to
+the same language.)  This is meant to handle legacy tags caused by
+the minor changes in language tag standards over the years; and
+the x-/i- alternation is also dealt with.
+
+Note that this function does I<not> try to equate new (and never-used,
+and unusable)
+ISO639-2 three-letter tags to old (and still in use) ISO639-1
+two-letter equivalents -- like "ara" -> "ar" -- because
+"ara" has I<never> been in use as an Internet language tag,
+and RFC 3066 stipulates that it never should be, since a shorter
+tag ("ar") exists.
+
+Examples:
+
+  alternate_language_tags('no-bok')       is ('nb')
+  alternate_language_tags('nb')           is ('no-bok')
+  alternate_language_tags('he')           is ('iw')
+  alternate_language_tags('iw')           is ('he')
+  alternate_language_tags('i-hakka')      is ('zh-hakka', 'x-hakka')
+  alternate_language_tags('zh-hakka')     is ('i-hakka', 'x-hakka')
+  alternate_language_tags('en')           is ()
+  alternate_language_tags('x-mingo-tom')  is ('i-mingo-tom')
+  alternate_language_tags('x-klikitat')   is ('i-klikitat')
+  alternate_language_tags('i-klikitat')   is ('x-klikitat')
+
+This function returns empty-list if given anything other than a formally
+valid language tag.
+
+=cut
+
+my %alt = qw( i x   x i   I X   X I );
+sub alternate_language_tags {
+  my $tag = $_[0];
+  return() unless &is_language_tag($tag);
+
+  my @em; # push 'em real goood!
+
+  # For the moment, these legacy variances are few enough that
+  #  we can just handle them here with regexps.
+  
+  if(     $tag =~ m/^[ix]-hakka\b(.*)/i) {push @em, "zh-hakka$1";
+  } elsif($tag =~ m/^zh-hakka\b(.*)/i) {  push @em, "x-hakka$1", "i-hakka$1";
+
+  } elsif($tag =~ m/^he\b(.*)/i) { push @em, "iw$1";
+  } elsif($tag =~ m/^iw\b(.*)/i) { push @em, "he$1";
+
+  } elsif($tag =~ m/^in\b(.*)/i) { push @em, "id$1";
+  } elsif($tag =~ m/^id\b(.*)/i) { push @em, "in$1";
+
+  } elsif($tag =~ m/^[ix]-lux\b(.*)/i) { push @em, "lb$1";
+  } elsif($tag =~ m/^lb\b(.*)/i) {       push @em, "i-lux$1", "x-lux$1";
+
+  } elsif($tag =~ m/^[ix]-navajo\b(.*)/i) { push @em, "nv$1";
+  } elsif($tag =~ m/^nv\b(.*)/i) {          push @em, "i-navajo$1", "x-navajo$1";
+
+  } elsif($tag =~ m/^yi\b(.*)/i) { push @em, "ji$1";
+  } elsif($tag =~ m/^ji\b(.*)/i) { push @em, "yi$1";
+
+  } elsif($tag =~ m/^nb\b(.*)/i) {     push @em, "no-bok$1";
+  } elsif($tag =~ m/^no-bok\b(.*)/i) { push @em, "nb$1";
+  
+  } elsif($tag =~ m/^nn\b(.*)/i) {     push @em, "no-nyn$1";
+  } elsif($tag =~ m/^no-nyn\b(.*)/i) { push @em, "nn$1";
+  }
+
+  push @em, $alt{$1} . $2 if $tag =~ /^([XIxi])(-.+)/;
+  return @em;
+}
+
+###########################################################################
+
+{
+  # Init %Panic...
+  
+  my @panic = (  # MUST all be lowercase!
+   # Only large ("national") languages make it in this list.
+   #  If you, as a user, are so bizarre that the /only/ language
+   #  you claim to accept is Galician, then no, we won't do you
+   #  the favor of providing Catalan as a panic-fallback for
+   #  you.  Because if I start trying to add "little languages" in
+   #  here, I'll just go crazy.
+
+   # Scandinavian lgs.  All based on opinion and hearsay.
+   'sv' => [qw(nb no da nn)],
+   'da' => [qw(nb no sv nn)], # I guess
+   [qw(no nn nb)], [qw(no nn nb sv da)],
+   'is' => [qw(da sv no nb nn)],
+   'fo' => [qw(da is no nb nn sv)], # I guess
+   
+   # I think this is about the extent of tolerable intelligibility
+   #  among large modern Romance languages.
+   'pt' => [qw(es ca it fr)], # Portuguese, Spanish, Catalan, Italian, French
+   'ca' => [qw(es pt it fr)],
+   'es' => [qw(ca it fr pt)],
+   'it' => [qw(es fr ca pt)],
+   'fr' => [qw(es it ca pt)],
+   
+   # Also assume that speakers of the main Indian languages prefer
+   #  to read/hear Hindi over English
+   [qw(
+     as bn gu kn ks kok ml mni mr ne or pa sa sd te ta ur
+   )] => 'hi',
+    # Assamese, Bengali, Gujarati, [Hindi,] Kannada (Kanarese), Kashmiri,
+    # Konkani, Malayalam, Meithei (Manipuri), Marathi, Nepali, Oriya,
+    # Punjabi, Sanskrit, Sindhi, Telugu, Tamil, and Urdu.
+   'hi' => [qw(bn pa as or)],
+   # I welcome finer data for the other Indian languages.
+   #  E.g., what should Oriya's list be, besides just Hindi?
+   
+   # And the panic languages for English is, of course, nil!
+
+   # My guesses at Slavic intelligibility:
+   ([qw(ru be uk)]) x 2,  # Russian, Belarusian, Ukrainian
+   ([qw(sr hr bs)]) x 2,  # Serbian, Croatian, Bosnian
+   'cs' => 'sk', 'sk' => 'cs', # Czech + Slovak
+
+   'ms' => 'id', 'id' => 'ms', # Malay + Indonesian
+
+   'et' => 'fi', 'fi' => 'et', # Estonian + Finnish
+
+   #?? 'lo' => 'th', 'th' => 'lo', # Lao + Thai
+
+  );
+  my($k,$v);
+  while(@panic) {
+    ($k,$v) = splice(@panic,0,2);
+    foreach my $k (ref($k) ? @$k : $k) {
+      foreach my $v (ref($v) ? @$v : $v) {
+        push @{$Panic{$k} ||= []}, $v unless $k eq $v;
+      }
+    }
+  }
+}
+
+=item * the function @langs = panic_languages(@accept_languages)
+
+This function takes a list of 0 or more language
+tags that constitute a given user's Accept-Language list, and
+returns a list of tags for I<other> (non-super)
+languages that are probably acceptable to the user, to be
+used I<if all else fails>.
+
+For example, if a user accepts only 'ca' (Catalan) and
+'es' (Spanish), and the documents/interfaces you have
+available are just in German, Italian, and Chinese, then
+the user will most likely want the Italian one (and not
+the Chinese or German one!), instead of getting
+nothing.  So C<panic_languages('ca', 'es')> returns
+a list containing 'it' (Italian).
+
+English ('en') is I<always> in the return list, but
+whether it's at the very end or not depends
+on the input languages.  This function works by consulting
+an internal table that stipulates what common
+languages are "close" to each other.
+
+A useful construct you might consider using is:
+
+  @fallbacks = super_languages(@accept_languages);
+  push @fallbacks, panic_languages(
+    @accept_languages, @fallbacks,
+  );
+
+=cut
+
+sub panic_languages {
+  # When in panic or in doubt, run in circles, scream, and shout!
+  my(@out, %seen);
+  foreach my $t (@_) {
+    next unless $t;
+    next if $seen{$t}++; # so we don't return it or hit it again
+    # push @out, super_languages($t); # nah, keep that separate
+    push @out, @{ $Panic{lc $t} || next };
+  }
+  return grep !$seen{$_}++,  @out, 'en';
+}
+
+#---------------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+=item * the function implicate_supers( ...languages... )
+
+This takes a list of strings (which are presumed to be language-tags;
+strings that aren't, are ignored); and after each one, this function
+inserts super-ordinate forms that don't already appear in the list.
+The original list, plus these insertions, is returned.
+
+In other words, it takes this:
+
+  pt-br de-DE en-US fr pt-br-janeiro
+
+and returns this:
+
+  pt-br pt de-DE de en-US en fr pt-br-janeiro
+
+This function is most useful in the idiom
+
+  implicate_supers( I18N::LangTags::Detect::detect() );
+
+(See L<I18N::LangTags::Detect>.)
+
+
+=item * the function implicate_supers_strictly( ...languages... )
+
+This works like C<implicate_supers> except that the implicated
+forms are added to the end of the return list.
+
+In other words, implicate_supers_strictly takes a list of strings
+(which are presumed to be language-tags; strings that aren't, are
+ignored) and after the whole given list, it inserts the super-ordinate forms 
+of all given tags, minus any tags that already appear in the input list.
+
+In other words, it takes this:
+
+  pt-br de-DE en-US fr pt-br-janeiro
+
+and returns this:
+
+  pt-br de-DE en-US fr pt-br-janeiro pt de en
+
+The reason this function has "_strictly" in its name is that when
+you're processing an Accept-Language list according to the RFCs, if
+you interpret the RFCs quite strictly, then you would use
+implicate_supers_strictly, but for normal use (i.e., common-sense use,
+as far as I'm concerned) you'd use implicate_supers.
+
+=cut
+
+sub implicate_supers {
+  my @languages = grep is_language_tag($_), @_;
+  my %seen_encoded;
+  foreach my $lang (@languages) {
+    $seen_encoded{ I18N::LangTags::encode_language_tag($lang) } = 1
+  }
+
+  my(@output_languages);
+  foreach my $lang (@languages) {
+    push @output_languages, $lang;
+    foreach my $s ( I18N::LangTags::super_languages($lang) ) {
+      # Note that super_languages returns the longest first.
+      last if $seen_encoded{ I18N::LangTags::encode_language_tag($s) };
+      push @output_languages, $s;
+    }
+  }
+  return uniq( @output_languages );
+
+}
+
+sub implicate_supers_strictly {
+  my @tags = grep is_language_tag($_), @_;
+  return uniq( @_,   map super_languages($_), @_ );
+}
+
+
+
+###########################################################################
+1;
+__END__
+
+=back
+
+=head1 ABOUT LOWERCASING
+
+I've considered making all the above functions that output language
+tags return all those tags strictly in lowercase.  Having all your
+language tags in lowercase does make some things easier.  But you
+might as well just lowercase as you like, or call
+C<encode_language_tag($lang1)> where appropriate.
+
+=head1 ABOUT UNICODE PLAINTEXT LANGUAGE TAGS
+
+In some future version of I18N::LangTags, I plan to include support
+for RFC2482-style language tags -- which are basically just normal
+language tags with their ASCII characters shifted into Plane 14.
+
+=head1 SEE ALSO
+
+* L<I18N::LangTags::List|I18N::LangTags::List>
+
+* RFC 3066, C<L<http://www.ietf.org/rfc/rfc3066.txt>>, "Tags for the
+Identification of Languages".  (Obsoletes RFC 1766)
+
+* RFC 2277, C<L<http://www.ietf.org/rfc/rfc2277.txt>>, "IETF Policy on
+Character Sets and Languages".
+
+* RFC 2231, C<L<http://www.ietf.org/rfc/rfc2231.txt>>, "MIME Parameter
+Value and Encoded Word Extensions: Character Sets, Languages, and
+Continuations".
+
+* RFC 2482, C<L<http://www.ietf.org/rfc/rfc2482.txt>>,
+"Language Tagging in Unicode Plain Text".
+
+* Locale::Codes, in
+C<L<http://www.perl.com/CPAN/modules/by-module/Locale/>>
+
+* ISO 639-2, "Codes for the representation of names of languages",
+including two-letter and three-letter codes,
+C<L<http://www.loc.gov/standards/iso639-2/php/code_list.php>>
+
+* The IANA list of registered languages (hopefully up-to-date),
+C<L<http://www.iana.org/assignments/language-tags>>
+
+=head1 COPYRIGHT
+
+Copyright (c) 1998+ Sean M. Burke. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+The programs and documentation in this dist are distributed in
+the hope that they will be useful, but without any warranty; without
+even the implied warranty of merchantability or fitness for a
+particular purpose.
+
+=head1 AUTHOR
+
+Sean M. Burke C<sburke@cpan.org>
+
+=cut
+

git/usr/share/perl5/core_perl/IO/Compress.pm

@@ -0,0 +1,27 @@
+package IO::Compress;
+
+our $VERSION = '2.213' ;
+
+=head1 NAME
+
+IO::Compress - read/write compressed data in multiple formats
+
+=head1 DESCRIPTION
+
+This is a stub module. It contains no code.
+
+=head1 AUTHOR
+
+Paul Marquess F<pmqs@cpan.org>.
+
+=head1 COPYRIGHT
+
+Copyright (c) 2011-2024 Paul Marquess. All rights reserved.
+
+This program is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=cut
+
+
+1;

git/usr/share/perl5/core_perl/IO/Zlib.pm

@@ -0,0 +1,740 @@
+# IO::Zlib.pm
+#
+# Copyright (c) 1998-2004 Tom Hughes <tom@compton.nu>.
+# All rights reserved. This program is free software; you can redistribute
+# it and/or modify it under the same terms as Perl itself.
+
+package IO::Zlib;
+
+=head1 NAME
+
+IO::Zlib - IO:: style interface to L<Compress::Zlib>
+
+=head1 SYNOPSIS
+
+With any version of Perl 5 you can use the basic OO interface:
+
+    use IO::Zlib;
+
+    $fh = new IO::Zlib;
+    if ($fh->open("file.gz", "rb")) {
+        print <$fh>;
+        $fh->close;
+    }
+
+    $fh = IO::Zlib->new("file.gz", "wb9");
+    if (defined $fh) {
+        print $fh "bar\n";
+        $fh->close;
+    }
+
+    $fh = IO::Zlib->new("file.gz", "rb");
+    if (defined $fh) {
+        print <$fh>;
+        undef $fh;       # automatically closes the file
+    }
+
+With Perl 5.004 you can also use the TIEHANDLE interface to access
+compressed files just like ordinary files:
+
+    use IO::Zlib;
+
+    tie *FILE, 'IO::Zlib', "file.gz", "wb";
+    print FILE "line 1\nline2\n";
+
+    tie *FILE, 'IO::Zlib', "file.gz", "rb";
+    while (<FILE>) { print "LINE: ", $_ };
+
+=head1 DESCRIPTION
+
+C<IO::Zlib> provides an IO:: style interface to L<Compress::Zlib> and
+hence to gzip/zlib compressed files. It provides many of the same methods
+as the L<IO::Handle> interface.
+
+Starting from IO::Zlib version 1.02, IO::Zlib can also use an
+external F<gzip> command.  The default behaviour is to try to use
+an external F<gzip> if no C<Compress::Zlib> can be loaded, unless
+explicitly disabled by
+
+    use IO::Zlib qw(:gzip_external 0);
+
+If explicitly enabled by
+
+    use IO::Zlib qw(:gzip_external 1);
+
+then the external F<gzip> is used B<instead> of C<Compress::Zlib>.
+
+=head1 CONSTRUCTOR
+
+=over 4
+
+=item new ( [ARGS] )
+
+Creates an C<IO::Zlib> object. If it receives any parameters, they are
+passed to the method C<open>; if the open fails, the object is destroyed.
+Otherwise, it is returned to the caller.
+
+=back
+
+=head1 OBJECT METHODS
+
+=over 4
+
+=item open ( FILENAME, MODE )
+
+C<open> takes two arguments. The first is the name of the file to open
+and the second is the open mode. The mode can be anything acceptable to
+L<Compress::Zlib> and by extension anything acceptable to I<zlib> (that
+basically means POSIX fopen() style mode strings plus an optional number
+to indicate the compression level).
+
+=item opened
+
+Returns true if the object currently refers to a opened file.
+
+=item close
+
+Close the file associated with the object and disassociate
+the file from the handle.
+Done automatically on destroy.
+
+=item getc
+
+Return the next character from the file, or undef if none remain.
+
+=item getline
+
+Return the next line from the file, or undef on end of string.
+Can safely be called in an array context.
+Currently ignores $/ ($INPUT_RECORD_SEPARATOR or $RS when L<English>
+is in use) and treats lines as delimited by "\n".
+
+=item getlines
+
+Get all remaining lines from the file.
+It will croak() if accidentally called in a scalar context.
+
+=item print ( ARGS... )
+
+Print ARGS to the  file.
+
+=item read ( BUF, NBYTES, [OFFSET] )
+
+Read some bytes from the file.
+Returns the number of bytes actually read, 0 on end-of-file, undef on error.
+
+=item eof
+
+Returns true if the handle is currently positioned at end of file?
+
+=item seek ( OFFSET, WHENCE )
+
+Seek to a given position in the stream.
+Not yet supported.
+
+=item tell
+
+Return the current position in the stream, as a numeric offset.
+Not yet supported.
+
+=item setpos ( POS )
+
+Set the current position, using the opaque value returned by C<getpos()>.
+Not yet supported.
+
+=item getpos ( POS )
+
+Return the current position in the string, as an opaque object.
+Not yet supported.
+
+=back
+
+=head1 USING THE EXTERNAL GZIP
+
+If the external F<gzip> is used, the following C<open>s are used:
+
+    open(FH, "gzip -dc $filename |")  # for read opens
+    open(FH, " | gzip > $filename")   # for write opens
+
+You can modify the 'commands' for example to hardwire
+an absolute path by e.g.
+
+    use IO::Zlib ':gzip_read_open'  => '/some/where/gunzip -c %s |';
+    use IO::Zlib ':gzip_write_open' => '| /some/where/gzip.exe > %s';
+
+The C<%s> is expanded to be the filename (C<sprintf> is used, so be
+careful to escape any other C<%> signs).  The 'commands' are checked
+for sanity - they must contain the C<%s>, and the read open must end
+with the pipe sign, and the write open must begin with the pipe sign.
+
+=head1 CLASS METHODS
+
+=over 4
+
+=item has_Compress_Zlib
+
+Returns true if C<Compress::Zlib> is available.  Note that this does
+not mean that C<Compress::Zlib> is being used: see L</gzip_external>
+and L<gzip_used>.
+
+=item gzip_external
+
+Undef if an external F<gzip> B<can> be used if C<Compress::Zlib> is
+not available (see L</has_Compress_Zlib>), true if an external F<gzip>
+is explicitly used, false if an external F<gzip> must not be used.
+See L</gzip_used>.
+
+=item gzip_used
+
+True if an external F<gzip> is being used, false if not.
+
+=item gzip_read_open
+
+Return the 'command' being used for opening a file for reading using an
+external F<gzip>.
+
+=item gzip_write_open
+
+Return the 'command' being used for opening a file for writing using an
+external F<gzip>.
+
+=back
+
+=head1 DIAGNOSTICS
+
+=over 4
+
+=item IO::Zlib::getlines: must be called in list context
+
+If you want read lines, you must read in list context.
+
+=item IO::Zlib::gzopen_external: mode '...' is illegal
+
+Use only modes 'rb' or 'wb' or /wb[1-9]/.
+
+=item IO::Zlib::import: '...' is illegal
+
+The known import symbols are the C<:gzip_external>, C<:gzip_read_open>,
+and C<:gzip_write_open>.  Anything else is not recognized.
+
+=item IO::Zlib::import: ':gzip_external' requires an argument
+
+The C<:gzip_external> requires one boolean argument.
+
+=item IO::Zlib::import: 'gzip_read_open' requires an argument
+
+The C<:gzip_external> requires one string argument.
+
+=item IO::Zlib::import: 'gzip_read' '...' is illegal
+
+The C<:gzip_read_open> argument must end with the pipe sign (|)
+and have the C<%s> for the filename.  See L</"USING THE EXTERNAL GZIP">.
+
+=item IO::Zlib::import: 'gzip_write_open' requires an argument
+
+The C<:gzip_external> requires one string argument.
+
+=item IO::Zlib::import: 'gzip_write_open' '...' is illegal
+
+The C<:gzip_write_open> argument must begin with the pipe sign (|)
+and have the C<%s> for the filename.  An output redirect (>) is also
+often a good idea, depending on your operating system shell syntax.
+See L</"USING THE EXTERNAL GZIP">.
+
+=item IO::Zlib::import: no Compress::Zlib and no external gzip
+
+Given that we failed to load C<Compress::Zlib> and that the use of
+ an external F<gzip> was disabled, IO::Zlib has not much chance of working.
+
+=item IO::Zlib::open: needs a filename
+
+No filename, no open.
+
+=item IO::Zlib::READ: NBYTES must be specified
+
+We must know how much to read.
+
+=item IO::Zlib::WRITE: too long LENGTH
+
+The LENGTH must be less than or equal to the buffer size.
+
+=back
+
+=head1 SEE ALSO
+
+L<perlfunc>,
+L<perlop/"I/O Operators">,
+L<IO::Handle>,
+L<Compress::Zlib>
+
+=head1 HISTORY
+
+Created by Tom Hughes E<lt>F<tom@compton.nu>E<gt>.
+
+Support for external gzip added by Jarkko Hietaniemi E<lt>F<jhi@iki.fi>E<gt>.
+
+=head1 COPYRIGHT
+
+Copyright (c) 1998-2004 Tom Hughes E<lt>F<tom@compton.nu>E<gt>.
+All rights reserved. This program is free software; you can redistribute
+it and/or modify it under the same terms as Perl itself.
+
+=cut
+
+require 5.006;
+
+use strict;
+use warnings;
+
+use Carp;
+use Fcntl qw(SEEK_SET);
+use Symbol;
+use Tie::Handle;
+
+our $VERSION = "1.15";
+our $AUTOLOAD;
+our @ISA = qw(Tie::Handle);
+
+my $has_Compress_Zlib;
+my $gzip_external;
+my $gzip_used;
+my $gzip_read_open = "gzip -dc %s |";
+my $gzip_write_open = "| gzip > %s";
+my $aliased;
+
+BEGIN {
+    eval { require Compress::Zlib };
+    $has_Compress_Zlib = $@ || $Compress::Zlib::VERSION < 2.000 ? 0 : 1;
+}
+
+sub has_Compress_Zlib
+{
+    $has_Compress_Zlib;
+}
+
+sub gzip_external
+{
+    $gzip_external;
+}
+
+sub gzip_used
+{
+    $gzip_used;
+}
+
+sub gzip_read_open
+{
+    $gzip_read_open;
+}
+
+sub gzip_write_open
+{
+    $gzip_write_open;
+}
+
+sub can_gunzip
+{
+    $has_Compress_Zlib || $gzip_external;
+}
+
+sub _import
+{
+    my $import = shift;
+
+    while (@_)
+    {
+        if ($_[0] eq ':gzip_external')
+        {
+            shift;
+
+            if (@_)
+            {
+                $gzip_external = shift;
+            }
+            else
+            {
+                croak "$import: ':gzip_external' requires an argument";
+            }
+        }
+        elsif ($_[0] eq ':gzip_read_open')
+        {
+            shift;
+
+            if (@_)
+            {
+                $gzip_read_open = shift;
+
+                croak "$import: ':gzip_read_open' '$gzip_read_open' is illegal"
+                    unless $gzip_read_open =~ /^.+%s.+\|\s*$/;
+            }
+            else
+            {
+                croak "$import: ':gzip_read_open' requires an argument";
+            }
+        }
+        elsif ($_[0] eq ':gzip_write_open')
+        {
+            shift;
+
+            if (@_)
+            {
+                $gzip_write_open = shift;
+
+                croak "$import: ':gzip_write_open' '$gzip_read_open' is illegal"
+                    unless $gzip_write_open =~ /^\s*\|.+%s.*$/;
+            }
+            else
+            {
+                croak "$import: ':gzip_write_open' requires an argument";
+            }
+        }
+        else
+        {
+            last;
+        }
+    }
+
+    return @_;
+}
+
+sub _alias
+{
+    my $import = shift;
+
+    if ($gzip_external || (!$has_Compress_Zlib && !defined($gzip_external)))
+    {
+        require IO::Handle;
+
+        undef *gzopen;
+        *gzopen = \&gzopen_external;
+
+        *IO::Handle::gzread = \&gzread_external;
+        *IO::Handle::gzwrite = \&gzwrite_external;
+        *IO::Handle::gzreadline = \&gzreadline_external;
+        *IO::Handle::gzeof = \&gzeof_external;
+        *IO::Handle::gzclose = \&gzclose_external;
+
+        $gzip_used = 1;
+    }
+    elsif ($has_Compress_Zlib)
+    {
+        *gzopen = \&Compress::Zlib::gzopen;
+        *gzread = \&Compress::Zlib::gzread;
+        *gzwrite = \&Compress::Zlib::gzwrite;
+        *gzreadline = \&Compress::Zlib::gzreadline;
+        *gzeof = \&Compress::Zlib::gzeof;
+    }
+    else
+    {
+        croak "$import: no Compress::Zlib and no external gzip";
+    }
+
+    $aliased = 1;
+}
+
+sub import
+{
+    my $class = shift;
+    my $import = "IO::Zlib::import";
+
+    if (@_)
+    {
+        if (_import($import, @_))
+        {
+            croak "$import: '@_' is illegal";
+        }
+    }
+
+    _alias($import);
+}
+
+sub TIEHANDLE
+{
+    my $class = shift;
+    my @args = @_;
+
+    my $self = bless {}, $class;
+
+    return @args ? $self->OPEN(@args) : $self;
+}
+
+sub DESTROY
+{
+}
+
+sub OPEN
+{
+    my $self = shift;
+    my $filename = shift;
+    my $mode = shift;
+
+    croak "IO::Zlib::open: needs a filename" unless defined($filename);
+
+    $self->{'file'} = gzopen($filename,$mode);
+
+    return defined($self->{'file'}) ? $self : undef;
+}
+
+sub CLOSE
+{
+    my $self = shift;
+
+    return undef unless defined($self->{'file'});
+
+    my $status = $self->{'file'}->gzclose();
+
+    delete $self->{'file'};
+
+    return ($status == 0) ? 1 : undef;
+}
+
+sub READ
+{
+    my $self = shift;
+    my $bufref = \$_[0];
+    my $nbytes = $_[1];
+    my $offset = $_[2] || 0;
+
+    croak "IO::Zlib::READ: NBYTES must be specified" unless defined($nbytes);
+
+    $$bufref = "" unless defined($$bufref);
+
+    my $bytesread = $self->{'file'}->gzread(substr($$bufref,$offset),$nbytes);
+
+    return undef if $bytesread < 0;
+
+    return $bytesread;
+}
+
+sub READLINE
+{
+    my $self = shift;
+
+    my $line;
+
+    return () if $self->{'file'}->gzreadline($line) <= 0;
+
+    return $line unless wantarray;
+
+    my @lines = $line;
+
+    while ($self->{'file'}->gzreadline($line) > 0)
+    {
+        push @lines, $line;
+    }
+
+    return @lines;
+}
+
+sub WRITE
+{
+    my $self = shift;
+    my $buf = shift;
+    my $length = shift;
+    my $offset = shift;
+
+    croak "IO::Zlib::WRITE: too long LENGTH" unless $offset + $length <= length($buf);
+
+    return $self->{'file'}->gzwrite(substr($buf,$offset,$length));
+}
+
+sub EOF
+{
+    my $self = shift;
+
+    return $self->{'file'}->gzeof();
+}
+
+sub FILENO
+{
+    return undef;
+}
+
+sub new
+{
+    my $class = shift;
+    my @args = @_;
+
+    _alias("new", @_) unless $aliased; # Some call new IO::Zlib directly...
+
+    my $self = gensym();
+
+    tie *{$self}, $class, @args;
+
+    return tied(${$self}) ? bless $self, $class : undef;
+}
+
+sub getline
+{
+    my $self = shift;
+
+    return scalar tied(*{$self})->READLINE();
+}
+
+sub getlines
+{
+    my $self = shift;
+
+    croak "IO::Zlib::getlines: must be called in list context"
+        unless wantarray;
+
+    return tied(*{$self})->READLINE();
+}
+
+sub opened
+{
+    my $self = shift;
+
+    return defined tied(*{$self})->{'file'};
+}
+
+sub AUTOLOAD
+{
+    my $self = shift;
+
+    $AUTOLOAD =~ s/.*:://;
+    $AUTOLOAD =~ tr/a-z/A-Z/;
+
+    return tied(*{$self})->$AUTOLOAD(@_);
+}
+
+sub gzopen_external
+{
+    my $filename = shift;
+    my $mode = shift;
+    my $fh = IO::Handle->new();
+
+    if ($mode =~ /r/)
+    {
+        # Because someone will try to read ungzipped files
+        # with this we peek and verify the signature.  Yes,
+        # this means that we open the file twice (if it is
+        # gzipped).
+        # Plenty of race conditions exist in this code, but
+        # the alternative would be to capture the stderr of
+        # gzip and parse it, which would be a portability nightmare.
+        if (-e $filename && open($fh, $filename))
+        {
+            binmode $fh;
+
+            my $sig;
+            my $rdb = read($fh, $sig, 2);
+
+            if ($rdb == 2 && $sig eq "\x1F\x8B")
+            {
+                my $ropen = sprintf($gzip_read_open, $filename);
+
+                if (open($fh, $ropen))
+                {
+                    binmode $fh;
+
+                    return $fh;
+                }
+                else
+                {
+                    return undef;
+                }
+            }
+
+            seek($fh, 0, SEEK_SET) or
+                die "IO::Zlib: open('$filename', 'r'): seek: $!";
+
+            return $fh;
+        }
+        else
+        {
+            return undef;
+        }
+    }
+    elsif ($mode =~ /w/)
+    {
+        my $level = $mode =~ /([1-9])/ ? "-$1" : "";
+
+        # To maximize portability we would need to open
+        # two filehandles here, one for "| gzip $level"
+        # and another for "> $filename", and then when
+        # writing copy bytes from the first to the second.
+        # We are using IO::Handle objects for now, however,
+        # and they can only contain one stream at a time.
+        my $wopen = sprintf($gzip_write_open, $filename);
+
+        if (open($fh, $wopen))
+        {
+            $fh->autoflush(1);
+            binmode $fh;
+
+            return $fh;
+        }
+        else
+        {
+            return undef;
+        }
+    }
+    else
+    {
+        croak "IO::Zlib::gzopen_external: mode '$mode' is illegal";
+    }
+
+    return undef;
+}
+
+sub gzread_external
+{
+    my $file = shift;
+    my $bufref = \$_[0];
+    my $nbytes = $_[1] || 4096;
+
+    # Use read() instead of sysread() because people may
+    # mix reads and readlines, and we don't want to mess
+    # the stdio buffering.  See also gzreadline_external()
+    # and gzwrite_external().
+    my $nread = read($file, $$bufref, $nbytes);
+
+    return defined $nread ? $nread : -1;
+}
+
+sub gzwrite_external
+{
+    my $file = shift;
+    my $buf = shift;
+
+    # Using syswrite() is okay (cf. gzread_external())
+    # since the bytes leave this process and buffering
+    # is therefore not an issue.
+    my $nwrote = syswrite($file, $buf);
+
+    return defined $nwrote ? $nwrote : -1;
+}
+
+sub gzreadline_external
+{
+    my $file = shift;
+    my $bufref = \$_[0];
+
+    # See the comment in gzread_external().
+    $$bufref = readline($file);
+
+    return defined $$bufref ? length($$bufref) : -1;
+}
+
+sub gzeof_external
+{
+    my $file = shift;
+
+    return eof($file);
+}
+
+sub gzclose_external
+{
+    my $file = shift;
+
+    close($file);
+
+    # I am not entirely certain why this is needed but it seems
+    # the above close() always fails (as if the stream would have
+    # been already closed - something to do with using external
+    # processes via pipes?)
+    return 0;
+}
+
+1;

git/usr/share/perl5/core_perl/IPC/Cmd.pm

@@ -0,0 +1,2187 @@
+package IPC::Cmd;
+
+use strict;
+
+BEGIN {
+
+    use constant IS_VMS         => $^O eq 'VMS'                       ? 1 : 0;
+    use constant IS_WIN32       => $^O eq 'MSWin32'                   ? 1 : 0;
+    use constant IS_HPUX        => $^O eq 'hpux'                      ? 1 : 0;
+    use constant IS_WIN98       => (IS_WIN32 and !Win32::IsWinNT())   ? 1 : 0;
+    use constant ALARM_CLASS    => __PACKAGE__ . '::TimeOut';
+    use constant SPECIAL_CHARS  => qw[< > | &];
+    use constant QUOTE          => do { IS_WIN32 ? q["] : q['] };
+
+    use Exporter    ();
+    use vars        qw[ @ISA $VERSION @EXPORT_OK $VERBOSE $DEBUG
+                        $USE_IPC_RUN $USE_IPC_OPEN3 $CAN_USE_RUN_FORKED $WARN
+                        $INSTANCES $ALLOW_NULL_ARGS
+                        $HAVE_MONOTONIC
+                    ];
+
+    $VERSION        = '1.04';
+    $VERBOSE        = 0;
+    $DEBUG          = 0;
+    $WARN           = 1;
+    $USE_IPC_RUN    = IS_WIN32 && !IS_WIN98;
+    $USE_IPC_OPEN3  = not IS_VMS;
+    $ALLOW_NULL_ARGS = 0;
+
+    $CAN_USE_RUN_FORKED = 0;
+    eval {
+        require POSIX; POSIX->import();
+        require IPC::Open3; IPC::Open3->import();
+        require IO::Select; IO::Select->import();
+        require IO::Handle; IO::Handle->import();
+        require FileHandle; FileHandle->import();
+        require Socket;
+        require Time::HiRes; Time::HiRes->import();
+        require Win32 if IS_WIN32;
+    };
+    $CAN_USE_RUN_FORKED = $@ || !IS_VMS && !IS_WIN32;
+
+    eval {
+        my $wait_start_time = Time::HiRes::clock_gettime(&Time::HiRes::CLOCK_MONOTONIC);
+    };
+    if ($@) {
+        $HAVE_MONOTONIC = 0;
+    }
+    else {
+        $HAVE_MONOTONIC = 1;
+    }
+
+    @ISA            = qw[Exporter];
+    @EXPORT_OK      = qw[can_run run run_forked QUOTE];
+}
+
+require Carp;
+use File::Spec;
+use Params::Check               qw[check];
+use Text::ParseWords            ();             # import ONLY if needed!
+use Module::Load::Conditional   qw[can_load];
+use Locale::Maketext::Simple    Style => 'gettext';
+
+local $Module::Load::Conditional::FORCE_SAFE_INC = 1;
+
+=pod
+
+=head1 NAME
+
+IPC::Cmd - finding and running system commands made easy
+
+=head1 SYNOPSIS
+
+    use IPC::Cmd qw[can_run run run_forked];
+
+    my $full_path = can_run('wget') or warn 'wget is not installed!';
+
+    ### commands can be arrayrefs or strings ###
+    my $cmd = "$full_path -b theregister.co.uk";
+    my $cmd = [$full_path, '-b', 'theregister.co.uk'];
+
+    ### in scalar context ###
+    my $buffer;
+    if( scalar run( command => $cmd,
+                    verbose => 0,
+                    buffer  => \$buffer,
+                    timeout => 20 )
+    ) {
+        print "fetched webpage successfully: $buffer\n";
+    }
+
+
+    ### in list context ###
+    my( $success, $error_message, $full_buf, $stdout_buf, $stderr_buf ) =
+            run( command => $cmd, verbose => 0 );
+
+    if( $success ) {
+        print "this is what the command printed:\n";
+        print join "", @$full_buf;
+    }
+
+    ### run_forked example ###
+    my $result = run_forked("$full_path -q -O - theregister.co.uk", {'timeout' => 20});
+    if ($result->{'exit_code'} eq 0 && !$result->{'timeout'}) {
+        print "this is what wget returned:\n";
+        print $result->{'stdout'};
+    }
+
+    ### check for features
+    print "IPC::Open3 available: "  . IPC::Cmd->can_use_ipc_open3;
+    print "IPC::Run available: "    . IPC::Cmd->can_use_ipc_run;
+    print "Can capture buffer: "    . IPC::Cmd->can_capture_buffer;
+
+    ### don't have IPC::Cmd be verbose, ie don't print to stdout or
+    ### stderr when running commands -- default is '0'
+    $IPC::Cmd::VERBOSE = 0;
+
+
+=head1 DESCRIPTION
+
+IPC::Cmd allows you to run commands platform independently,
+interactively if desired, but have them still work.
+
+The C<can_run> function can tell you if a certain binary is installed
+and if so where, whereas the C<run> function can actually execute any
+of the commands you give it and give you a clear return value, as well
+as adhere to your verbosity settings.
+
+=head1 CLASS METHODS
+
+=head2 $ipc_run_version = IPC::Cmd->can_use_ipc_run( [VERBOSE] )
+
+Utility function that tells you if C<IPC::Run> is available.
+If the C<verbose> flag is passed, it will print diagnostic messages
+if L<IPC::Run> can not be found or loaded.
+
+=cut
+
+
+sub can_use_ipc_run     {
+    my $self    = shift;
+    my $verbose = shift || 0;
+
+    ### IPC::Run doesn't run on win98
+    return if IS_WIN98;
+
+    ### if we don't have ipc::run, we obviously can't use it.
+    return unless can_load(
+                        modules => { 'IPC::Run' => '0.55' },
+                        verbose => ($WARN && $verbose),
+                    );
+
+    ### otherwise, we're good to go
+    return $IPC::Run::VERSION;
+}
+
+=head2 $ipc_open3_version = IPC::Cmd->can_use_ipc_open3( [VERBOSE] )
+
+Utility function that tells you if C<IPC::Open3> is available.
+If the verbose flag is passed, it will print diagnostic messages
+if C<IPC::Open3> can not be found or loaded.
+
+=cut
+
+
+sub can_use_ipc_open3   {
+    my $self    = shift;
+    my $verbose = shift || 0;
+
+    ### IPC::Open3 is not working on VMS because of a lack of fork.
+    return if IS_VMS;
+
+    ### IPC::Open3 works on every non-VMS platform, but it can't
+    ### capture buffers on win32 :(
+    return unless can_load(
+        modules => { map {$_ => '0.0'} qw|IPC::Open3 IO::Select Symbol| },
+        verbose => ($WARN && $verbose),
+    );
+
+    return $IPC::Open3::VERSION;
+}
+
+=head2 $bool = IPC::Cmd->can_capture_buffer
+
+Utility function that tells you if C<IPC::Cmd> is capable of
+capturing buffers in it's current configuration.
+
+=cut
+
+sub can_capture_buffer {
+    my $self    = shift;
+
+    return 1 if $USE_IPC_RUN    && $self->can_use_ipc_run;
+    return 1 if $USE_IPC_OPEN3  && $self->can_use_ipc_open3;
+    return;
+}
+
+=head2 $bool = IPC::Cmd->can_use_run_forked
+
+Utility function that tells you if C<IPC::Cmd> is capable of
+providing C<run_forked> on the current platform.
+
+=head1 FUNCTIONS
+
+=head2 $path = can_run( PROGRAM );
+
+C<can_run> takes only one argument: the name of a binary you wish
+to locate. C<can_run> works much like the unix binary C<which> or the bash
+command C<type>, which scans through your path, looking for the requested
+binary.
+
+Unlike C<which> and C<type>, this function is platform independent and
+will also work on, for example, Win32.
+
+If called in a scalar context it will return the full path to the binary
+you asked for if it was found, or C<undef> if it was not.
+
+If called in a list context and the global variable C<$INSTANCES> is a true
+value, it will return a list of the full paths to instances
+of the binary where found in C<PATH>, or an empty list if it was not found.
+
+=cut
+
+sub can_run {
+    my $command = shift;
+
+    # a lot of VMS executables have a symbol defined
+    # check those first
+    if ( $^O eq 'VMS' ) {
+        require VMS::DCLsym;
+        my $syms = VMS::DCLsym->new;
+        return $command if scalar $syms->getsym( uc $command );
+    }
+
+    require File::Spec;
+    require ExtUtils::MakeMaker;
+
+    my @possibles;
+
+    if( File::Spec->file_name_is_absolute($command) ) {
+        return MM->maybe_command($command);
+
+    } else {
+        for my $dir (
+            File::Spec->path,
+            ( IS_WIN32 ? File::Spec->curdir : () )
+        ) {
+            next if ! $dir || ! -d $dir;
+            my $abs = File::Spec->catfile( IS_WIN32 ? Win32::GetShortPathName( $dir ) : $dir, $command);
+            push @possibles, $abs if $abs = MM->maybe_command($abs);
+        }
+    }
+    return @possibles if wantarray and $INSTANCES;
+    return shift @possibles;
+}
+
+=head2 $ok | ($ok, $err, $full_buf, $stdout_buff, $stderr_buff) = run( command => COMMAND, [verbose => BOOL, buffer => \$SCALAR, timeout => DIGIT] );
+
+C<run> takes 4 arguments:
+
+=over 4
+
+=item command
+
+This is the command to execute. It may be either a string or an array
+reference.
+This is a required argument.
+
+See L<"Caveats"> for remarks on how commands are parsed and their
+limitations.
+
+=item verbose
+
+This controls whether all output of a command should also be printed
+to STDOUT/STDERR or should only be trapped in buffers (NOTE: buffers
+require L<IPC::Run> to be installed, or your system able to work with
+L<IPC::Open3>).
+
+It will default to the global setting of C<$IPC::Cmd::VERBOSE>,
+which by default is 0.
+
+=item buffer
+
+This will hold all the output of a command. It needs to be a reference
+to a scalar.
+Note that this will hold both the STDOUT and STDERR messages, and you
+have no way of telling which is which.
+If you require this distinction, run the C<run> command in list context
+and inspect the individual buffers.
+
+Of course, this requires that the underlying call supports buffers. See
+the note on buffers above.
+
+=item timeout
+
+Sets the maximum time the command is allowed to run before aborting,
+using the built-in C<alarm()> call. If the timeout is triggered, the
+C<errorcode> in the return value will be set to an object of the
+C<IPC::Cmd::TimeOut> class. See the L<"error message"> section below for
+details.
+
+Defaults to C<0>, meaning no timeout is set.
+
+=back
+
+C<run> will return a simple C<true> or C<false> when called in scalar
+context.
+In list context, you will be returned a list of the following items:
+
+=over 4
+
+=item success
+
+A simple boolean indicating if the command executed without errors or
+not.
+
+=item error message
+
+If the first element of the return value (C<success>) was 0, then some
+error occurred. This second element is the error message the command
+you requested exited with, if available. This is generally a pretty
+printed value of C<$?> or C<$@>. See C<perldoc perlvar> for details on
+what they can contain.
+If the error was a timeout, the C<error message> will be prefixed with
+the string C<IPC::Cmd::TimeOut>, the timeout class.
+
+=item full_buffer
+
+This is an array reference containing all the output the command
+generated.
+Note that buffers are only available if you have L<IPC::Run> installed,
+or if your system is able to work with L<IPC::Open3> -- see below).
+Otherwise, this element will be C<undef>.
+
+=item out_buffer
+
+This is an array reference containing all the output sent to STDOUT the
+command generated. The notes from L<"full_buffer"> apply.
+
+=item error_buffer
+
+This is an arrayreference containing all the output sent to STDERR the
+command generated. The notes from L<"full_buffer"> apply.
+
+
+=back
+
+See the L<"HOW IT WORKS"> section below to see how C<IPC::Cmd> decides
+what modules or function calls to use when issuing a command.
+
+=cut
+
+{   my @acc = qw[ok error _fds];
+
+    ### autogenerate accessors ###
+    for my $key ( @acc ) {
+        no strict 'refs';
+        *{__PACKAGE__."::$key"} = sub {
+            $_[0]->{$key} = $_[1] if @_ > 1;
+            return $_[0]->{$key};
+        }
+    }
+}
+
+sub can_use_run_forked {
+    return $CAN_USE_RUN_FORKED eq "1";
+}
+
+sub get_monotonic_time {
+    if ($HAVE_MONOTONIC) {
+        return Time::HiRes::clock_gettime(&Time::HiRes::CLOCK_MONOTONIC);
+    }
+    else {
+        return time();
+    }
+}
+
+sub adjust_monotonic_start_time {
+    my ($ref_vars, $now, $previous) = @_;
+
+    # workaround only for those systems which don't have
+    # Time::HiRes::CLOCK_MONOTONIC (Mac OSX in particular)
+    return if $HAVE_MONOTONIC;
+
+    # don't have previous monotonic value (only happens once
+    # in the beginning of the program execution)
+    return unless $previous;
+
+    my $time_diff = $now - $previous;
+
+    # adjust previously saved time with the skew value which is
+    # either negative when clock moved back or more than 5 seconds --
+    # assuming that event loop does happen more often than once
+    # per five seconds, which might not be always true (!) but
+    # hopefully that's ok, because it's just a workaround
+    if ($time_diff > 5 || $time_diff < 0) {
+        foreach my $ref_var (@{$ref_vars}) {
+            if (defined($$ref_var)) {
+                $$ref_var = $$ref_var + $time_diff;
+            }
+        }
+    }
+}
+
+sub uninstall_signals {
+		return unless defined($IPC::Cmd::{'__old_signals'});
+
+		foreach my $sig_name (keys %{$IPC::Cmd::{'__old_signals'}}) {
+				$SIG{$sig_name} = $IPC::Cmd::{'__old_signals'}->{$sig_name};
+		}
+}
+
+# incompatible with POSIX::SigAction
+#
+sub install_layered_signal {
+  my ($s, $handler_code) = @_;
+
+  my %available_signals = map {$_ => 1} keys %SIG;
+
+  Carp::confess("install_layered_signal got nonexistent signal name [$s]")
+    unless defined($available_signals{$s});
+  Carp::confess("install_layered_signal expects coderef")
+    if !ref($handler_code) || ref($handler_code) ne 'CODE';
+
+  $IPC::Cmd::{'__old_signals'} = {}
+  		unless defined($IPC::Cmd::{'__old_signals'});
+	$IPC::Cmd::{'__old_signals'}->{$s} = $SIG{$s};
+
+  my $previous_handler = $SIG{$s};
+
+  my $sig_handler = sub {
+    my ($called_sig_name, @sig_param) = @_;
+
+    # $s is a closure referring to real signal name
+    # for which this handler is being installed.
+    # it is used to distinguish between
+    # real signal handlers and aliased signal handlers
+    my $signal_name = $s;
+
+    # $called_sig_name is a signal name which
+    # was passed to this signal handler;
+    # it doesn't equal $signal_name in case
+    # some signal handlers in %SIG point
+    # to other signal handler (CHLD and CLD,
+    # ABRT and IOT)
+    #
+    # initial signal handler for aliased signal
+    # calls some other signal handler which
+    # should not execute the same handler_code again
+    if ($called_sig_name eq $signal_name) {
+      $handler_code->($signal_name);
+    }
+
+    # run original signal handler if any (including aliased)
+    #
+    if (ref($previous_handler)) {
+      $previous_handler->($called_sig_name, @sig_param);
+    }
+  };
+
+  $SIG{$s} = $sig_handler;
+}
+
+# give process a chance sending TERM,
+# waiting for a while (2 seconds)
+# and killing it with KILL
+sub kill_gently {
+  my ($pid, $opts) = @_;
+
+  require POSIX;
+
+  $opts = {} unless $opts;
+  $opts->{'wait_time'} = 2 unless defined($opts->{'wait_time'});
+  $opts->{'first_kill_type'} = 'just_process' unless $opts->{'first_kill_type'};
+  $opts->{'final_kill_type'} = 'just_process' unless $opts->{'final_kill_type'};
+
+  if ($opts->{'first_kill_type'} eq 'just_process') {
+    kill(15, $pid);
+  }
+  elsif ($opts->{'first_kill_type'} eq 'process_group') {
+    kill(-15, $pid);
+  }
+
+  my $do_wait = 1;
+  my $child_finished = 0;
+
+  my $wait_start_time = get_monotonic_time();
+  my $now;
+  my $previous_monotonic_value;
+
+  while ($do_wait) {
+    $previous_monotonic_value = $now;
+    $now = get_monotonic_time();
+
+    adjust_monotonic_start_time([\$wait_start_time], $now, $previous_monotonic_value);
+
+    if ($now > $wait_start_time + $opts->{'wait_time'}) {
+        $do_wait = 0;
+        next;
+    }
+
+    my $waitpid = waitpid($pid, POSIX::WNOHANG);
+
+    if ($waitpid eq -1) {
+        $child_finished = 1;
+        $do_wait = 0;
+        next;
+    }
+
+    Time::HiRes::usleep(250000); # quarter of a second
+  }
+
+  if (!$child_finished) {
+    if ($opts->{'final_kill_type'} eq 'just_process') {
+      kill(9, $pid);
+    }
+    elsif ($opts->{'final_kill_type'} eq 'process_group') {
+      kill(-9, $pid);
+    }
+  }
+}
+
+sub open3_run {
+    my ($cmd, $opts) = @_;
+
+    $opts = {} unless $opts;
+
+    my $child_in = FileHandle->new;
+    my $child_out = FileHandle->new;
+    my $child_err = FileHandle->new;
+    $child_out->autoflush(1);
+    $child_err->autoflush(1);
+
+    my $pid = open3($child_in, $child_out, $child_err, $cmd);
+    Time::HiRes::usleep(1) if IS_HPUX;
+
+    # will consider myself orphan if my ppid changes
+    # from this one:
+    my $original_ppid = $opts->{'original_ppid'};
+
+    # push my child's pid to our parent
+    # so in case i am killed parent
+    # could stop my child (search for
+    # child_child_pid in parent code)
+    if ($opts->{'parent_info'}) {
+      my $ps = $opts->{'parent_info'};
+      print $ps "spawned $pid\n";
+    }
+
+    if ($child_in && $child_out->opened && $opts->{'child_stdin'}) {
+        # If the child process dies for any reason,
+        # the next write to CHLD_IN is likely to generate
+        # a SIGPIPE in the parent, which is fatal by default.
+        # So you may wish to handle this signal.
+        #
+        # from http://perldoc.perl.org/IPC/Open3.html,
+        # absolutely needed to catch piped commands errors.
+        #
+        local $SIG{'PIPE'} = sub { 1; };
+
+        print $child_in $opts->{'child_stdin'};
+    }
+    close($child_in);
+
+    my $child_output = {
+        'out' => $child_out->fileno,
+        'err' => $child_err->fileno,
+        $child_out->fileno => {
+            'parent_socket' => $opts->{'parent_stdout'},
+            'scalar_buffer' => "",
+            'child_handle' => $child_out,
+            'block_size' => ($child_out->stat)[11] || 1024,
+          },
+        $child_err->fileno => {
+            'parent_socket' => $opts->{'parent_stderr'},
+            'scalar_buffer' => "",
+            'child_handle' => $child_err,
+            'block_size' => ($child_err->stat)[11] || 1024,
+          },
+        };
+
+    my $select = IO::Select->new();
+    $select->add($child_out, $child_err);
+
+    # pass any signal to the child
+    # effectively creating process
+    # strongly attached to the child:
+    # it will terminate only after child
+    # has terminated (except for SIGKILL,
+    # which is specially handled)
+    SIGNAL: foreach my $s (keys %SIG) {
+        next SIGNAL if $s eq '__WARN__' or $s eq '__DIE__'; # Skip and don't clobber __DIE__ & __WARN__
+        my $sig_handler;
+        $sig_handler = sub {
+            kill("$s", $pid);
+            $SIG{$s} = $sig_handler;
+        };
+        $SIG{$s} = $sig_handler;
+    }
+
+    my $child_finished = 0;
+
+    my $real_exit;
+    my $exit_value;
+
+    while(!$child_finished) {
+
+        # parent was killed otherwise we would have got
+        # the same signal as parent and process it same way
+        if (getppid() != $original_ppid) {
+
+          # end my process group with all the children
+          # (i am the process group leader, so my pid
+          # equals to the process group id)
+          #
+          # same thing which is done
+          # with $opts->{'clean_up_children'}
+          # in run_forked
+          #
+          kill(-9, $$);
+
+          POSIX::_exit 1;
+        }
+
+        my $waitpid = waitpid($pid, POSIX::WNOHANG);
+
+        # child finished, catch it's exit status
+        if ($waitpid ne 0 && $waitpid ne -1) {
+          $real_exit = $?;
+          $exit_value = $? >> 8;
+        }
+
+        if ($waitpid eq -1) {
+          $child_finished = 1;
+        }
+
+
+        my $ready_fds = [];
+        push @{$ready_fds}, $select->can_read(1/100);
+
+        READY_FDS: while (scalar(@{$ready_fds})) {
+            my $fd = shift @{$ready_fds};
+            $ready_fds = [grep {$_ ne $fd} @{$ready_fds}];
+
+            my $str = $child_output->{$fd->fileno};
+            Carp::confess("child stream not found: $fd") unless $str;
+
+            my $data;
+            my $count = $fd->sysread($data, $str->{'block_size'});
+
+            if ($count) {
+                if ($str->{'parent_socket'}) {
+                    my $ph = $str->{'parent_socket'};
+                    print $ph $data;
+                }
+                else {
+                    $str->{'scalar_buffer'} .= $data;
+                }
+            }
+            elsif ($count eq 0) {
+                $select->remove($fd);
+                $fd->close();
+            }
+            else {
+                Carp::confess("error during sysread: " . $!);
+            }
+
+            push @{$ready_fds}, $select->can_read(1/100) if $child_finished;
+        }
+
+        Time::HiRes::usleep(1);
+    }
+
+    # since we've successfully reaped the child,
+    # let our parent know about this.
+    #
+    if ($opts->{'parent_info'}) {
+        my $ps = $opts->{'parent_info'};
+
+        # child was killed, inform parent
+        if ($real_exit & 127) {
+          print $ps "$pid killed with " . ($real_exit & 127) . "\n";
+        }
+
+        print $ps "reaped $pid\n";
+    }
+
+    if ($opts->{'parent_stdout'} || $opts->{'parent_stderr'}) {
+        return $exit_value;
+    }
+    else {
+        return {
+            'stdout' => $child_output->{$child_output->{'out'}}->{'scalar_buffer'},
+            'stderr' => $child_output->{$child_output->{'err'}}->{'scalar_buffer'},
+            'exit_code' => $exit_value,
+            };
+    }
+}
+
+=head2 $hashref = run_forked( COMMAND, { child_stdin => SCALAR, timeout => DIGIT, stdout_handler => CODEREF, stderr_handler => CODEREF} );
+
+C<run_forked> is used to execute some program or a coderef,
+optionally feed it with some input, get its return code
+and output (both stdout and stderr into separate buffers).
+In addition, it allows to terminate the program
+if it takes too long to finish.
+
+The important and distinguishing feature of run_forked
+is execution timeout which at first seems to be
+quite a simple task but if you think
+that the program which you're spawning
+might spawn some children itself (which
+in their turn could do the same and so on)
+it turns out to be not a simple issue.
+
+C<run_forked> is designed to survive and
+successfully terminate almost any long running task,
+even a fork bomb in case your system has the resources
+to survive during given timeout.
+
+This is achieved by creating separate watchdog process
+which spawns the specified program in a separate
+process session and supervises it: optionally
+feeds it with input, stores its exit code,
+stdout and stderr, terminates it in case
+it runs longer than specified.
+
+Invocation requires the command to be executed or a coderef and optionally a hashref of options:
+
+=over
+
+=item C<timeout>
+
+Specify in seconds how long to run the command before it is killed with SIG_KILL (9),
+which effectively terminates it and all of its children (direct or indirect).
+
+=item C<child_stdin>
+
+Specify some text that will be passed into the C<STDIN> of the executed program.
+
+=item C<stdout_handler>
+
+Coderef of a subroutine to call when a portion of data is received on
+STDOUT from the executing program.
+
+=item C<stderr_handler>
+
+Coderef of a subroutine to call when a portion of data is received on
+STDERR from the executing program.
+
+=item C<wait_loop_callback>
+
+Coderef of a subroutine to call inside of the main waiting loop
+(while C<run_forked> waits for the external to finish or fail).
+It is useful to stop running external process before it ends
+by itself, e.g.
+
+  my $r = run_forked("some external command", {
+	  'wait_loop_callback' => sub {
+          if (condition) {
+              kill(1, $$);
+          }
+	  },
+	  'terminate_on_signal' => 'HUP',
+	  });
+
+Combined with C<stdout_handler> and C<stderr_handler> allows terminating
+external command based on its output. Could also be used as a timer
+without engaging with L<alarm> (signals).
+
+Remember that this code could be called every millisecond (depending
+on the output which external command generates), so try to make it
+as lightweight as possible.
+
+=item C<discard_output>
+
+Discards the buffering of the standard output and standard errors for return by run_forked().
+With this option you have to use the std*_handlers to read what the command outputs.
+Useful for commands that send a lot of output.
+
+=item C<terminate_on_parent_sudden_death>
+
+Enable this option if you wish all spawned processes to be killed if the initially spawned
+process (the parent) is killed or dies without waiting for child processes.
+
+=back
+
+C<run_forked> will return a HASHREF with the following keys:
+
+=over
+
+=item C<exit_code>
+
+The exit code of the executed program.
+
+=item C<timeout>
+
+The number of seconds the program ran for before being terminated, or 0 if no timeout occurred.
+
+=item C<stdout>
+
+Holds the standard output of the executed command (or empty string if
+there was no STDOUT output or if C<discard_output> was used; it's always defined!)
+
+=item C<stderr>
+
+Holds the standard error of the executed command (or empty string if
+there was no STDERR output or if C<discard_output> was used; it's always defined!)
+
+=item C<merged>
+
+Holds the standard output and error of the executed command merged into one stream
+(or empty string if there was no output at all or if C<discard_output> was used; it's always defined!)
+
+=item C<err_msg>
+
+Holds some explanation in the case of an error.
+
+=back
+
+=cut
+
+sub run_forked {
+    ### container to store things in
+    my $self = bless {}, __PACKAGE__;
+
+    if (!can_use_run_forked()) {
+        Carp::carp("run_forked is not available: $CAN_USE_RUN_FORKED");
+        return;
+    }
+
+    require POSIX;
+
+    my ($cmd, $opts) = @_;
+    if (ref($cmd) eq 'ARRAY') {
+        $cmd = join(" ", @{$cmd});
+    }
+
+    if (!$cmd) {
+        Carp::carp("run_forked expects command to run");
+        return;
+    }
+
+    $opts = {} unless $opts;
+    $opts->{'timeout'} = 0 unless $opts->{'timeout'};
+    $opts->{'terminate_wait_time'} = 2 unless defined($opts->{'terminate_wait_time'});
+
+    # turned on by default
+    $opts->{'clean_up_children'} = 1 unless defined($opts->{'clean_up_children'});
+
+    # sockets to pass child stdout to parent
+    my $child_stdout_socket;
+    my $parent_stdout_socket;
+
+    # sockets to pass child stderr to parent
+    my $child_stderr_socket;
+    my $parent_stderr_socket;
+
+    # sockets for child -> parent internal communication
+    my $child_info_socket;
+    my $parent_info_socket;
+
+    socketpair($child_stdout_socket, $parent_stdout_socket, &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC) ||
+      Carp::confess ("socketpair: $!");
+    socketpair($child_stderr_socket, $parent_stderr_socket, &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC) ||
+      Carp::confess ("socketpair: $!");
+    socketpair($child_info_socket, $parent_info_socket, &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC) ||
+      Carp::confess ("socketpair: $!");
+
+    $child_stdout_socket->autoflush(1);
+    $parent_stdout_socket->autoflush(1);
+    $child_stderr_socket->autoflush(1);
+    $parent_stderr_socket->autoflush(1);
+    $child_info_socket->autoflush(1);
+    $parent_info_socket->autoflush(1);
+
+    my $start_time = get_monotonic_time();
+
+    my $pid;
+    my $ppid = $$;
+    if ($pid = fork) {
+
+      # we are a parent
+      close($parent_stdout_socket);
+      close($parent_stderr_socket);
+      close($parent_info_socket);
+
+      my $flags;
+
+      # prepare sockets to read from child
+
+      $flags = fcntl($child_stdout_socket, POSIX::F_GETFL, 0) || Carp::confess "can't fnctl F_GETFL: $!";
+      $flags |= POSIX::O_NONBLOCK;
+      fcntl($child_stdout_socket, POSIX::F_SETFL, $flags) || Carp::confess "can't fnctl F_SETFL: $!";
+
+      $flags = fcntl($child_stderr_socket, POSIX::F_GETFL, 0) || Carp::confess "can't fnctl F_GETFL: $!";
+      $flags |= POSIX::O_NONBLOCK;
+      fcntl($child_stderr_socket, POSIX::F_SETFL, $flags) || Carp::confess "can't fnctl F_SETFL: $!";
+
+      $flags = fcntl($child_info_socket, POSIX::F_GETFL, 0) || Carp::confess "can't fnctl F_GETFL: $!";
+      $flags |= POSIX::O_NONBLOCK;
+      fcntl($child_info_socket, POSIX::F_SETFL, $flags) || Carp::confess "can't fnctl F_SETFL: $!";
+
+  #    print "child $pid started\n";
+
+      my $child_output = {
+        $child_stdout_socket->fileno => {
+          'scalar_buffer' => "",
+          'child_handle' => $child_stdout_socket,
+          'block_size' => ($child_stdout_socket->stat)[11] || 1024,
+          'protocol' => 'stdout',
+          },
+        $child_stderr_socket->fileno => {
+          'scalar_buffer' => "",
+          'child_handle' => $child_stderr_socket,
+          'block_size' => ($child_stderr_socket->stat)[11] || 1024,
+          'protocol' => 'stderr',
+          },
+        $child_info_socket->fileno => {
+          'scalar_buffer' => "",
+          'child_handle' => $child_info_socket,
+          'block_size' => ($child_info_socket->stat)[11] || 1024,
+          'protocol' => 'info',
+          },
+        };
+
+      my $select = IO::Select->new();
+      $select->add($child_stdout_socket, $child_stderr_socket, $child_info_socket);
+
+      my $child_timedout = 0;
+      my $child_finished = 0;
+      my $child_stdout = '';
+      my $child_stderr = '';
+      my $child_merged = '';
+      my $child_exit_code = 0;
+      my $child_killed_by_signal = 0;
+      my $parent_died = 0;
+
+      my $last_parent_check = 0;
+      my $got_sig_child = 0;
+      my $got_sig_quit = 0;
+      my $orig_sig_child = $SIG{'CHLD'};
+
+      $SIG{'CHLD'} = sub { $got_sig_child = get_monotonic_time(); };
+
+      if ($opts->{'terminate_on_signal'}) {
+        install_layered_signal($opts->{'terminate_on_signal'}, sub { $got_sig_quit = time(); });
+      }
+
+      my $child_child_pid;
+      my $now;
+      my $previous_monotonic_value;
+
+      while (!$child_finished) {
+        $previous_monotonic_value = $now;
+        $now = get_monotonic_time();
+
+        adjust_monotonic_start_time([\$start_time, \$last_parent_check, \$got_sig_child], $now, $previous_monotonic_value);
+
+        if ($opts->{'terminate_on_parent_sudden_death'}) {
+          # check for parent once each five seconds
+          if ($now > $last_parent_check + 5) {
+            if (getppid() eq "1") {
+              kill_gently ($pid, {
+                'first_kill_type' => 'process_group',
+                'final_kill_type' => 'process_group',
+                'wait_time' => $opts->{'terminate_wait_time'}
+                });
+              $parent_died = 1;
+            }
+
+            $last_parent_check = $now;
+          }
+        }
+
+        # user specified timeout
+        if ($opts->{'timeout'}) {
+          if ($now > $start_time + $opts->{'timeout'}) {
+            kill_gently ($pid, {
+              'first_kill_type' => 'process_group',
+              'final_kill_type' => 'process_group',
+              'wait_time' => $opts->{'terminate_wait_time'}
+              });
+            $child_timedout = 1;
+          }
+        }
+
+        # give OS 10 seconds for correct return of waitpid,
+        # kill process after that and finish wait loop;
+        # shouldn't ever happen -- remove this code?
+        if ($got_sig_child) {
+          if ($now > $got_sig_child + 10) {
+            print STDERR "waitpid did not return -1 for 10 seconds after SIG_CHLD, killing [$pid]\n";
+            kill (-9, $pid);
+            $child_finished = 1;
+          }
+        }
+
+        if ($got_sig_quit) {
+          kill_gently ($pid, {
+            'first_kill_type' => 'process_group',
+            'final_kill_type' => 'process_group',
+            'wait_time' => $opts->{'terminate_wait_time'}
+            });
+          $child_finished = 1;
+        }
+
+        my $waitpid = waitpid($pid, POSIX::WNOHANG);
+
+        # child finished, catch it's exit status
+        if ($waitpid ne 0 && $waitpid ne -1) {
+          $child_exit_code = $? >> 8;
+        }
+
+        if ($waitpid eq -1) {
+          $child_finished = 1;
+        }
+
+        my $ready_fds = [];
+        push @{$ready_fds}, $select->can_read(1/100);
+
+        READY_FDS: while (scalar(@{$ready_fds})) {
+          my $fd = shift @{$ready_fds};
+          $ready_fds = [grep {$_ ne $fd} @{$ready_fds}];
+
+          my $str = $child_output->{$fd->fileno};
+          Carp::confess("child stream not found: $fd") unless $str;
+
+          my $data = "";
+          my $count = $fd->sysread($data, $str->{'block_size'});
+
+          if ($count) {
+              # extract all the available lines and store the rest in temporary buffer
+              if ($data =~ /(.+\n)([^\n]*)/so) {
+                  $data = $str->{'scalar_buffer'} . $1;
+                  $str->{'scalar_buffer'} = $2 || "";
+              }
+              else {
+                  $str->{'scalar_buffer'} .= $data;
+                  $data = "";
+              }
+          }
+          elsif ($count eq 0) {
+            $select->remove($fd);
+            $fd->close();
+            if ($str->{'scalar_buffer'}) {
+                $data = $str->{'scalar_buffer'} . "\n";
+            }
+          }
+          else {
+            Carp::confess("error during sysread on [$fd]: " . $!);
+          }
+
+          # $data contains only full lines (or last line if it was unfinished read
+          # or now new-line in the output of the child); dat is processed
+          # according to the "protocol" of socket
+          if ($str->{'protocol'} eq 'info') {
+            if ($data =~ /^spawned ([0-9]+?)\n(.*?)/so) {
+              $child_child_pid = $1;
+              $data = $2;
+            }
+            if ($data =~ /^reaped ([0-9]+?)\n(.*?)/so) {
+              $child_child_pid = undef;
+              $data = $2;
+            }
+            if ($data =~ /^[\d]+ killed with ([0-9]+?)\n(.*?)/so) {
+              $child_killed_by_signal = $1;
+              $data = $2;
+            }
+
+            # we don't expect any other data in info socket, so it's
+            # some strange violation of protocol, better know about this
+            if ($data) {
+              Carp::confess("info protocol violation: [$data]");
+            }
+          }
+          if ($str->{'protocol'} eq 'stdout') {
+            if (!$opts->{'discard_output'}) {
+              $child_stdout .= $data;
+              $child_merged .= $data;
+            }
+
+            if ($opts->{'stdout_handler'} && ref($opts->{'stdout_handler'}) eq 'CODE') {
+              $opts->{'stdout_handler'}->($data);
+            }
+          }
+          if ($str->{'protocol'} eq 'stderr') {
+            if (!$opts->{'discard_output'}) {
+              $child_stderr .= $data;
+              $child_merged .= $data;
+            }
+
+            if ($opts->{'stderr_handler'} && ref($opts->{'stderr_handler'}) eq 'CODE') {
+              $opts->{'stderr_handler'}->($data);
+            }
+          }
+ 
+          # process may finish (waitpid returns -1) before
+          # we've read all of its output because of buffering;
+          # so try to read all the way it is possible to read
+          # in such case - this shouldn't be too much (unless
+          # the buffer size is HUGE -- should introduce
+          # another counter in such case, maybe later)
+          #
+          push @{$ready_fds}, $select->can_read(1/100) if $child_finished;
+        }
+
+        if ($opts->{'wait_loop_callback'} && ref($opts->{'wait_loop_callback'}) eq 'CODE') {
+          $opts->{'wait_loop_callback'}->();
+        }
+
+        Time::HiRes::usleep(1);
+      }
+
+      # $child_pid_pid is not defined in two cases:
+      #  * when our child was killed before
+      #    it had chance to tell us the pid
+      #    of the child it spawned. we can do
+      #    nothing in this case :(
+      #  * our child successfully reaped its child,
+      #    we have nothing left to do in this case
+      #
+      # defined $child_pid_pid means child's child
+      # has not died but nobody is waiting for it,
+      # killing it brutally.
+      #
+      if ($child_child_pid) {
+        kill_gently($child_child_pid);
+      }
+
+      # in case there are forks in child which
+      # do not forward or process signals (TERM) correctly
+      # kill whole child process group, effectively trying
+      # not to return with some children or their parts still running
+      #
+      # to be more accurate -- we need to be sure
+      # that this is process group created by our child
+      # (and not some other process group with the same pgid,
+      # created just after death of our child) -- fortunately
+      # this might happen only when process group ids
+      # are reused quickly (there are lots of processes
+      # spawning new process groups for example)
+      #
+      if ($opts->{'clean_up_children'}) {
+        kill(-9, $pid);
+      }
+
+  #    print "child $pid finished\n";
+
+      close($child_stdout_socket);
+      close($child_stderr_socket);
+      close($child_info_socket);
+
+      my $o = {
+        'stdout' => $child_stdout,
+        'stderr' => $child_stderr,
+        'merged' => $child_merged,
+        'timeout' => $child_timedout ? $opts->{'timeout'} : 0,
+        'exit_code' => $child_exit_code,
+        'parent_died' => $parent_died,
+        'killed_by_signal' => $child_killed_by_signal,
+        'child_pgid' => $pid,
+        'cmd' => $cmd,
+        };
+
+      my $err_msg = '';
+      if ($o->{'exit_code'}) {
+        $err_msg .= "exited with code [$o->{'exit_code'}]\n";
+      }
+      if ($o->{'timeout'}) {
+        $err_msg .= "ran more than [$o->{'timeout'}] seconds\n";
+      }
+      if ($o->{'parent_died'}) {
+        $err_msg .= "parent died\n";
+      }
+      if ($o->{'stdout'} && !$opts->{'non_empty_stdout_ok'}) {
+        $err_msg .= "stdout:\n" . $o->{'stdout'} . "\n";
+      }
+      if ($o->{'stderr'}) {
+        $err_msg .= "stderr:\n" . $o->{'stderr'} . "\n";
+      }
+      if ($o->{'killed_by_signal'}) {
+        $err_msg .= "killed by signal [" . $o->{'killed_by_signal'} . "]\n";
+      }
+      $o->{'err_msg'} = $err_msg;
+
+      if ($orig_sig_child) {
+        $SIG{'CHLD'} = $orig_sig_child;
+      }
+      else {
+        delete($SIG{'CHLD'});
+      }
+
+      uninstall_signals();
+
+      return $o;
+    }
+    else {
+      Carp::confess("cannot fork: $!") unless defined($pid);
+
+      # create new process session for open3 call,
+      # so we hopefully can kill all the subprocesses
+      # which might be spawned in it (except for those
+      # which do setsid theirselves -- can't do anything
+      # with those)
+
+      POSIX::setsid() == -1 and Carp::confess("Error running setsid: " . $!);
+
+      if ($opts->{'child_BEGIN'} && ref($opts->{'child_BEGIN'}) eq 'CODE') {
+        $opts->{'child_BEGIN'}->();
+      }
+
+      close($child_stdout_socket);
+      close($child_stderr_socket);
+      close($child_info_socket);
+
+      my $child_exit_code;
+
+      # allow both external programs
+      # and internal perl calls
+      if (!ref($cmd)) {
+        $child_exit_code = open3_run($cmd, {
+          'parent_info' => $parent_info_socket,
+          'parent_stdout' => $parent_stdout_socket,
+          'parent_stderr' => $parent_stderr_socket,
+          'child_stdin' => $opts->{'child_stdin'},
+          'original_ppid' => $ppid,
+          });
+      }
+      elsif (ref($cmd) eq 'CODE') {
+        # reopen STDOUT and STDERR for child code:
+        # https://rt.cpan.org/Ticket/Display.html?id=85912
+        open STDOUT, '>&', $parent_stdout_socket || Carp::confess("Unable to reopen STDOUT: $!\n");
+        open STDERR, '>&', $parent_stderr_socket || Carp::confess("Unable to reopen STDERR: $!\n");
+
+        $child_exit_code = $cmd->({
+          'opts' => $opts,
+          'parent_info' => $parent_info_socket,
+          'parent_stdout' => $parent_stdout_socket,
+          'parent_stderr' => $parent_stderr_socket,
+          'child_stdin' => $opts->{'child_stdin'},
+          });
+      }
+      else {
+        print $parent_stderr_socket "Invalid command reference: " . ref($cmd) . "\n";
+        $child_exit_code = 1;
+      }
+
+      close($parent_stdout_socket);
+      close($parent_stderr_socket);
+      close($parent_info_socket);
+
+      if ($opts->{'child_END'} && ref($opts->{'child_END'}) eq 'CODE') {
+        $opts->{'child_END'}->();
+      }
+
+      $| = 1;
+      POSIX::_exit $child_exit_code;
+    }
+}
+
+sub run {
+    ### container to store things in
+    my $self = bless {}, __PACKAGE__;
+
+    my %hash = @_;
+
+    ### if the user didn't provide a buffer, we'll store it here.
+    my $def_buf = '';
+
+    my($verbose,$cmd,$buffer,$timeout);
+    my $tmpl = {
+        verbose => { default  => $VERBOSE,  store => \$verbose },
+        buffer  => { default  => \$def_buf, store => \$buffer },
+        command => { required => 1,         store => \$cmd,
+                     allow    => sub { !ref($_[0]) or ref($_[0]) eq 'ARRAY' },
+        },
+        timeout => { default  => 0,         store => \$timeout },
+    };
+
+    unless( check( $tmpl, \%hash, $VERBOSE ) ) {
+        Carp::carp( loc( "Could not validate input: %1",
+                         Params::Check->last_error ) );
+        return;
+    };
+
+    $cmd = _quote_args_vms( $cmd ) if IS_VMS;
+
+    ### strip any empty elements from $cmd if present
+    if ( $ALLOW_NULL_ARGS ) {
+      $cmd = [ grep { defined } @$cmd ] if ref $cmd;
+    }
+    else {
+      $cmd = [ grep { defined && length } @$cmd ] if ref $cmd;
+    }
+
+    my $pp_cmd = (ref $cmd ? "@$cmd" : $cmd);
+    print loc("Running [%1]...\n", $pp_cmd ) if $verbose;
+
+    ### did the user pass us a buffer to fill or not? if so, set this
+    ### flag so we know what is expected of us
+    ### XXX this is now being ignored. in the future, we could add diagnostic
+    ### messages based on this logic
+    #my $user_provided_buffer = $buffer == \$def_buf ? 0 : 1;
+
+    ### buffers that are to be captured
+    my( @buffer, @buff_err, @buff_out );
+
+    ### capture STDOUT
+    my $_out_handler = sub {
+        my $buf = shift;
+        return unless defined $buf;
+
+        print STDOUT $buf if $verbose;
+        push @buffer,   $buf;
+        push @buff_out, $buf;
+    };
+
+    ### capture STDERR
+    my $_err_handler = sub {
+        my $buf = shift;
+        return unless defined $buf;
+
+        print STDERR $buf if $verbose;
+        push @buffer,   $buf;
+        push @buff_err, $buf;
+    };
+
+
+    ### flag to indicate we have a buffer captured
+    my $have_buffer = $self->can_capture_buffer ? 1 : 0;
+
+    ### flag indicating if the subcall went ok
+    my $ok;
+
+    ### don't look at previous errors:
+    local $?;
+    local $@;
+    local $!;
+
+    ### we might be having a timeout set
+    eval {
+        local $SIG{ALRM} = sub { die bless sub {
+            ALARM_CLASS .
+            qq[: Command '$pp_cmd' aborted by alarm after $timeout seconds]
+        }, ALARM_CLASS } if $timeout;
+        alarm $timeout || 0;
+
+        ### IPC::Run is first choice if $USE_IPC_RUN is set.
+        if( !IS_WIN32 and $USE_IPC_RUN and $self->can_use_ipc_run( 1 ) ) {
+            ### ipc::run handlers needs the command as a string or an array ref
+
+            $self->_debug( "# Using IPC::Run. Have buffer: $have_buffer" )
+                if $DEBUG;
+
+            $ok = $self->_ipc_run( $cmd, $_out_handler, $_err_handler );
+
+        ### since IPC::Open3 works on all platforms, and just fails on
+        ### win32 for capturing buffers, do that ideally
+        } elsif ( $USE_IPC_OPEN3 and $self->can_use_ipc_open3( 1 ) ) {
+
+            $self->_debug("# Using IPC::Open3. Have buffer: $have_buffer")
+                if $DEBUG;
+
+            ### in case there are pipes in there;
+            ### IPC::Open3 will call exec and exec will do the right thing
+
+            my $method = IS_WIN32 ? '_open3_run_win32' : '_open3_run';
+
+            $ok = $self->$method(
+                                    $cmd, $_out_handler, $_err_handler, $verbose
+                                );
+
+        ### if we are allowed to run verbose, just dispatch the system command
+        } else {
+            $self->_debug( "# Using system(). Have buffer: $have_buffer" )
+                if $DEBUG;
+            $ok = $self->_system_run( $cmd, $verbose );
+        }
+
+        alarm 0;
+    };
+
+    ### restore STDIN after duping, or STDIN will be closed for
+    ### this current perl process!
+    $self->__reopen_fds( @{ $self->_fds} ) if $self->_fds;
+
+    my $err;
+    unless( $ok ) {
+        ### alarm happened
+        if ( $@ and ref $@ and $@->isa( ALARM_CLASS ) ) {
+            $err = $@->();  # the error code is an expired alarm
+
+        ### another error happened, set by the dispatchub
+        } else {
+            $err = $self->error;
+        }
+    }
+
+    ### fill the buffer;
+    $$buffer = join '', @buffer if @buffer;
+
+    ### return a list of flags and buffers (if available) in list
+    ### context, or just a simple 'ok' in scalar
+    return wantarray
+                ? $have_buffer
+                    ? ($ok, $err, \@buffer, \@buff_out, \@buff_err)
+                    : ($ok, $err )
+                : $ok
+
+
+}
+
+sub _open3_run_win32 {
+  my $self    = shift;
+  my $cmd     = shift;
+  my $outhand = shift;
+  my $errhand = shift;
+
+  require Socket;
+
+  my $pipe = sub {
+    socketpair($_[0], $_[1], &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC)
+        or return undef;
+    shutdown($_[0], 1);  # No more writing for reader
+    shutdown($_[1], 0);  # No more reading for writer
+    return 1;
+  };
+
+  my $open3 = sub {
+    local (*TO_CHLD_R,     *TO_CHLD_W);
+    local (*FR_CHLD_R,     *FR_CHLD_W);
+    local (*FR_CHLD_ERR_R, *FR_CHLD_ERR_W);
+
+    $pipe->(*TO_CHLD_R,     *TO_CHLD_W    ) or die $^E;
+    $pipe->(*FR_CHLD_R,     *FR_CHLD_W    ) or die $^E;
+    $pipe->(*FR_CHLD_ERR_R, *FR_CHLD_ERR_W) or die $^E;
+
+    my $pid = IPC::Open3::open3('>&TO_CHLD_R', '<&FR_CHLD_W', '<&FR_CHLD_ERR_W', @_);
+
+    return ( $pid, *TO_CHLD_W, *FR_CHLD_R, *FR_CHLD_ERR_R );
+  };
+
+  $cmd = [ grep { defined && length } @$cmd ] if ref $cmd;
+  $cmd = $self->__fix_cmd_whitespace_and_special_chars( $cmd );
+
+  my ($pid, $to_chld, $fr_chld, $fr_chld_err) =
+    $open3->( ( ref $cmd ? @$cmd : $cmd ) );
+
+  my $in_sel  = IO::Select->new();
+  my $out_sel = IO::Select->new();
+
+  my %objs;
+
+  $objs{ fileno( $fr_chld ) } = $outhand;
+  $objs{ fileno( $fr_chld_err ) } = $errhand;
+  $in_sel->add( $fr_chld );
+  $in_sel->add( $fr_chld_err );
+
+  close($to_chld);
+
+  while ($in_sel->count() + $out_sel->count()) {
+    my ($ins, $outs) = IO::Select::select($in_sel, $out_sel, undef);
+
+    for my $fh (@$ins) {
+        my $obj = $objs{ fileno($fh) };
+        my $buf;
+        my $bytes_read = sysread($fh, $buf, 64*1024 ); #, length($buf));
+        if (!$bytes_read) {
+            $in_sel->remove($fh);
+        }
+        else {
+            $obj->( "$buf" );
+        }
+      }
+
+      for my $fh (@$outs) {
+      }
+  }
+
+  waitpid($pid, 0);
+
+  ### some error occurred
+  if( $? ) {
+        $self->error( $self->_pp_child_error( $cmd, $? ) );
+        $self->ok( 0 );
+        return;
+  } else {
+        return $self->ok( 1 );
+  }
+}
+
+sub _open3_run {
+    my $self            = shift;
+    my $cmd             = shift;
+    my $_out_handler    = shift;
+    my $_err_handler    = shift;
+    my $verbose         = shift || 0;
+
+    ### Following code are adapted from Friar 'abstracts' in the
+    ### Perl Monastery (http://www.perlmonks.org/index.pl?node_id=151886).
+    ### XXX that code didn't work.
+    ### we now use the following code, thanks to theorbtwo
+
+    ### define them beforehand, so we always have defined FH's
+    ### to read from.
+    use Symbol;
+    my $kidout      = Symbol::gensym();
+    my $kiderror    = Symbol::gensym();
+
+    ### Dup the filehandle so we can pass 'our' STDIN to the
+    ### child process. This stops us from having to pump input
+    ### from ourselves to the childprocess. However, we will need
+    ### to revive the FH afterwards, as IPC::Open3 closes it.
+    ### We'll do the same for STDOUT and STDERR. It works without
+    ### duping them on non-unix derivatives, but not on win32.
+    my @fds_to_dup = ( IS_WIN32 && !$verbose
+                            ? qw[STDIN STDOUT STDERR]
+                            : qw[STDIN]
+                        );
+    $self->_fds( \@fds_to_dup );
+    $self->__dup_fds( @fds_to_dup );
+
+    ### pipes have to come in a quoted string, and that clashes with
+    ### whitespace. This sub fixes up such commands so they run properly
+    $cmd = $self->__fix_cmd_whitespace_and_special_chars( $cmd );
+
+    ### don't stringify @$cmd, so spaces in filenames/paths are
+    ### treated properly
+    my $pid = eval {
+        IPC::Open3::open3(
+                    '<&STDIN',
+                    (IS_WIN32 ? '>&STDOUT' : $kidout),
+                    (IS_WIN32 ? '>&STDERR' : $kiderror),
+                    ( ref $cmd ? @$cmd : $cmd ),
+                );
+    };
+
+    ### open3 error occurred
+    if( $@ and $@ =~ /^open3:/ ) {
+        $self->ok( 0 );
+        $self->error( $@ );
+        return;
+    };
+
+    ### use OUR stdin, not $kidin. Somehow,
+    ### we never get the input.. so jump through
+    ### some hoops to do it :(
+    my $selector = IO::Select->new(
+                        (IS_WIN32 ? \*STDERR : $kiderror),
+                        \*STDIN,
+                        (IS_WIN32 ? \*STDOUT : $kidout)
+                    );
+
+    STDOUT->autoflush(1);   STDERR->autoflush(1);   STDIN->autoflush(1);
+    $kidout->autoflush(1)   if UNIVERSAL::can($kidout,   'autoflush');
+    $kiderror->autoflush(1) if UNIVERSAL::can($kiderror, 'autoflush');
+
+    ### add an explicit break statement
+    ### code courtesy of theorbtwo from #london.pm
+    my $stdout_done = 0;
+    my $stderr_done = 0;
+    OUTER: while ( my @ready = $selector->can_read ) {
+
+        for my $h ( @ready ) {
+            my $buf;
+
+            ### $len is the amount of bytes read
+            my $len = sysread( $h, $buf, 4096 );    # try to read 4096 bytes
+
+            ### see perldoc -f sysread: it returns undef on error,
+            ### so bail out.
+            if( not defined $len ) {
+                warn(loc("Error reading from process: %1", $!));
+                last OUTER;
+            }
+
+            ### check for $len. it may be 0, at which point we're
+            ### done reading, so don't try to process it.
+            ### if we would print anyway, we'd provide bogus information
+            $_out_handler->( "$buf" ) if $len && $h == $kidout;
+            $_err_handler->( "$buf" ) if $len && $h == $kiderror;
+
+            ### Wait till child process is done printing to both
+            ### stdout and stderr.
+            $stdout_done = 1 if $h == $kidout   and $len == 0;
+            $stderr_done = 1 if $h == $kiderror and $len == 0;
+            last OUTER if ($stdout_done && $stderr_done);
+        }
+    }
+
+    waitpid $pid, 0; # wait for it to die
+
+    ### restore STDIN after duping, or STDIN will be closed for
+    ### this current perl process!
+    ### done in the parent call now
+    # $self->__reopen_fds( @fds_to_dup );
+
+    ### some error occurred
+    if( $? ) {
+        $self->error( $self->_pp_child_error( $cmd, $? ) );
+        $self->ok( 0 );
+        return;
+    } else {
+        return $self->ok( 1 );
+    }
+}
+
+### Text::ParseWords::shellwords() uses unix semantics. that will break
+### on win32
+{   my $parse_sub = IS_WIN32
+                        ? __PACKAGE__->can('_split_like_shell_win32')
+                        : Text::ParseWords->can('shellwords');
+
+    sub _ipc_run {
+        my $self            = shift;
+        my $cmd             = shift;
+        my $_out_handler    = shift;
+        my $_err_handler    = shift;
+
+        STDOUT->autoflush(1); STDERR->autoflush(1);
+
+        ### a command like:
+        # [
+        #     '/usr/bin/gzip',
+        #     '-cdf',
+        #     '/Users/kane/sources/p4/other/archive-extract/t/src/x.tgz',
+        #     '|',
+        #     '/usr/bin/tar',
+        #     '-tf -'
+        # ]
+        ### needs to become:
+        # [
+        #     ['/usr/bin/gzip', '-cdf',
+        #       '/Users/kane/sources/p4/other/archive-extract/t/src/x.tgz']
+        #     '|',
+        #     ['/usr/bin/tar', '-tf -']
+        # ]
+
+
+        my @command;
+        my $special_chars;
+
+        my $re = do { my $x = join '', SPECIAL_CHARS; qr/([$x])/ };
+        if( ref $cmd ) {
+            my $aref = [];
+            for my $item (@$cmd) {
+                if( $item =~ $re ) {
+                    push @command, $aref, $item;
+                    $aref = [];
+                    $special_chars .= $1;
+                } else {
+                    push @$aref, $item;
+                }
+            }
+            push @command, $aref;
+        } else {
+            @command = map { if( $_ =~ $re ) {
+                                $special_chars .= $1; $_;
+                             } else {
+#                                [ split /\s+/ ]
+                                 [ map { m/[ ]/ ? qq{'$_'} : $_ } $parse_sub->($_) ]
+                             }
+                        } split( /\s*$re\s*/, $cmd );
+        }
+
+        ### if there's a pipe in the command, *STDIN needs to
+        ### be inserted *BEFORE* the pipe, to work on win32
+        ### this also works on *nix, so we should do it when possible
+        ### this should *also* work on multiple pipes in the command
+        ### if there's no pipe in the command, append STDIN to the back
+        ### of the command instead.
+        ### XXX seems IPC::Run works it out for itself if you just
+        ### don't pass STDIN at all.
+        #     if( $special_chars and $special_chars =~ /\|/ ) {
+        #         ### only add STDIN the first time..
+        #         my $i;
+        #         @command = map { ($_ eq '|' && not $i++)
+        #                             ? ( \*STDIN, $_ )
+        #                             : $_
+        #                         } @command;
+        #     } else {
+        #         push @command, \*STDIN;
+        #     }
+
+        # \*STDIN is already included in the @command, see a few lines up
+        my $ok = eval { IPC::Run::run(   @command,
+                                fileno(STDOUT).'>',
+                                $_out_handler,
+                                fileno(STDERR).'>',
+                                $_err_handler
+                            )
+                        };
+
+        ### all is well
+        if( $ok ) {
+            return $self->ok( $ok );
+
+        ### some error occurred
+        } else {
+            $self->ok( 0 );
+
+            ### if the eval fails due to an exception, deal with it
+            ### unless it's an alarm
+            if( $@ and not UNIVERSAL::isa( $@, ALARM_CLASS ) ) {
+                $self->error( $@ );
+
+            ### if it *is* an alarm, propagate
+            } elsif( $@ ) {
+                die $@;
+
+            ### some error in the sub command
+            } else {
+                $self->error( $self->_pp_child_error( $cmd, $? ) );
+            }
+
+            return;
+        }
+    }
+}
+
+sub _system_run {
+    my $self    = shift;
+    my $cmd     = shift;
+    my $verbose = shift || 0;
+
+    ### pipes have to come in a quoted string, and that clashes with
+    ### whitespace. This sub fixes up such commands so they run properly
+    $cmd = $self->__fix_cmd_whitespace_and_special_chars( $cmd );
+
+    my @fds_to_dup = $verbose ? () : qw[STDOUT STDERR];
+    $self->_fds( \@fds_to_dup );
+    $self->__dup_fds( @fds_to_dup );
+
+    ### system returns 'true' on failure -- the exit code of the cmd
+    $self->ok( 1 );
+    system( ref $cmd ? @$cmd : $cmd ) == 0 or do {
+        $self->error( $self->_pp_child_error( $cmd, $? ) );
+        $self->ok( 0 );
+    };
+
+    ### done in the parent call now
+    #$self->__reopen_fds( @fds_to_dup );
+
+    return unless $self->ok;
+    return $self->ok;
+}
+
+{   my %sc_lookup = map { $_ => $_ } SPECIAL_CHARS;
+
+
+    sub __fix_cmd_whitespace_and_special_chars {
+        my $self = shift;
+        my $cmd  = shift;
+
+        ### command has a special char in it
+        if( ref $cmd and grep { $sc_lookup{$_} } @$cmd ) {
+
+            ### since we have special chars, we have to quote white space
+            ### this *may* conflict with the parsing :(
+            my $fixed;
+            my @cmd = map { / / ? do { $fixed++; QUOTE.$_.QUOTE } : $_ } @$cmd;
+
+            $self->_debug( "# Quoted $fixed arguments containing whitespace" )
+                    if $DEBUG && $fixed;
+
+            ### stringify it, so the special char isn't escaped as argument
+            ### to the program
+            $cmd = join ' ', @cmd;
+        }
+
+        return $cmd;
+    }
+}
+
+### Command-line arguments (but not the command itself) must be quoted
+### to ensure case preservation. Borrowed from Module::Build with adaptations.
+### Patch for this supplied by Craig Berry, see RT #46288: [PATCH] Add argument
+### quoting for run() on VMS
+sub _quote_args_vms {
+  ### Returns a command string with proper quoting so that the subprocess
+  ### sees this same list of args, or if we get a single arg that is an
+  ### array reference, quote the elements of it (except for the first)
+  ### and return the reference.
+  my @args = @_;
+  my $got_arrayref = (scalar(@args) == 1
+                      && UNIVERSAL::isa($args[0], 'ARRAY'))
+                   ? 1
+                   : 0;
+
+  @args = split(/\s+/, $args[0]) unless $got_arrayref || scalar(@args) > 1;
+
+  my $cmd = $got_arrayref ? shift @{$args[0]} : shift @args;
+
+  ### Do not quote qualifiers that begin with '/' or previously quoted args.
+  map { if (/^[^\/\"]/) {
+          $_ =~ s/\"/""/g;     # escape C<"> by doubling
+          $_ = q(").$_.q(");
+        }
+  }
+    ($got_arrayref ? @{$args[0]}
+                   : @args
+    );
+
+  $got_arrayref ? unshift(@{$args[0]}, $cmd) : unshift(@args, $cmd);
+
+  return $got_arrayref ? $args[0]
+                       : join(' ', @args);
+}
+
+
+### XXX this is cribbed STRAIGHT from M::B 0.30 here:
+### http://search.cpan.org/src/KWILLIAMS/Module-Build-0.30/lib/Module/Build/Platform/Windows.pm:split_like_shell
+### XXX this *should* be integrated into text::parsewords
+sub _split_like_shell_win32 {
+  # As it turns out, Windows command-parsing is very different from
+  # Unix command-parsing.  Double-quotes mean different things,
+  # backslashes don't necessarily mean escapes, and so on.  So we
+  # can't use Text::ParseWords::shellwords() to break a command string
+  # into words.  The algorithm below was bashed out by Randy and Ken
+  # (mostly Randy), and there are a lot of regression tests, so we
+  # should feel free to adjust if desired.
+
+  local $_ = shift;
+
+  my @argv;
+  return @argv unless defined() && length();
+
+  my $arg = '';
+  my( $i, $quote_mode ) = ( 0, 0 );
+
+  while ( $i < length() ) {
+
+    my $ch      = substr( $_, $i  , 1 );
+    my $next_ch = substr( $_, $i+1, 1 );
+
+    if ( $ch eq '\\' && $next_ch eq '"' ) {
+      $arg .= '"';
+      $i++;
+    } elsif ( $ch eq '\\' && $next_ch eq '\\' ) {
+      $arg .= '\\';
+      $i++;
+    } elsif ( $ch eq '"' && $next_ch eq '"' && $quote_mode ) {
+      $quote_mode = !$quote_mode;
+      $arg .= '"';
+      $i++;
+    } elsif ( $ch eq '"' && $next_ch eq '"' && !$quote_mode &&
+          ( $i + 2 == length()  ||
+        substr( $_, $i + 2, 1 ) eq ' ' )
+        ) { # for cases like: a"" => [ 'a' ]
+      push( @argv, $arg );
+      $arg = '';
+      $i += 2;
+    } elsif ( $ch eq '"' ) {
+      $quote_mode = !$quote_mode;
+    } elsif ( $ch eq ' ' && !$quote_mode ) {
+      push( @argv, $arg ) if defined( $arg ) && length( $arg );
+      $arg = '';
+      ++$i while substr( $_, $i + 1, 1 ) eq ' ';
+    } else {
+      $arg .= $ch;
+    }
+
+    $i++;
+  }
+
+  push( @argv, $arg ) if defined( $arg ) && length( $arg );
+  return @argv;
+}
+
+
+
+{   use File::Spec;
+    use Symbol;
+
+    my %Map = (
+        STDOUT => [qw|>&|, \*STDOUT, Symbol::gensym() ],
+        STDERR => [qw|>&|, \*STDERR, Symbol::gensym() ],
+        STDIN  => [qw|<&|, \*STDIN,  Symbol::gensym() ],
+    );
+
+    ### dups FDs and stores them in a cache
+    sub __dup_fds {
+        my $self    = shift;
+        my @fds     = @_;
+
+        __PACKAGE__->_debug( "# Closing the following fds: @fds" ) if $DEBUG;
+
+        for my $name ( @fds ) {
+            my($redir, $fh, $glob) = @{$Map{$name}} or (
+                Carp::carp(loc("No such FD: '%1'", $name)), next );
+
+            ### MUST use the 2-arg version of open for dup'ing for
+            ### 5.6.x compatibility. 5.8.x can use 3-arg open
+            ### see perldoc5.6.2 -f open for details
+            open $glob, $redir . fileno($fh) or (
+                        Carp::carp(loc("Could not dup '$name': %1", $!)),
+                        return
+                    );
+
+            ### we should re-open this filehandle right now, not
+            ### just dup it
+            ### Use 2-arg version of open, as 5.5.x doesn't support
+            ### 3-arg version =/
+            if( $redir eq '>&' ) {
+                open( $fh, '>' . File::Spec->devnull ) or (
+                    Carp::carp(loc("Could not reopen '$name': %1", $!)),
+                    return
+                );
+            }
+        }
+
+        return 1;
+    }
+
+    ### reopens FDs from the cache
+    sub __reopen_fds {
+        my $self    = shift;
+        my @fds     = @_;
+
+        __PACKAGE__->_debug( "# Reopening the following fds: @fds" ) if $DEBUG;
+
+        for my $name ( @fds ) {
+            my($redir, $fh, $glob) = @{$Map{$name}} or (
+                Carp::carp(loc("No such FD: '%1'", $name)), next );
+
+            ### MUST use the 2-arg version of open for dup'ing for
+            ### 5.6.x compatibility. 5.8.x can use 3-arg open
+            ### see perldoc5.6.2 -f open for details
+            open( $fh, $redir . fileno($glob) ) or (
+                    Carp::carp(loc("Could not restore '$name': %1", $!)),
+                    return
+                );
+
+            ### close this FD, we're not using it anymore
+            close $glob;
+        }
+        return 1;
+
+    }
+}
+
+sub _debug {
+    my $self    = shift;
+    my $msg     = shift or return;
+    my $level   = shift || 0;
+
+    local $Carp::CarpLevel += $level;
+    Carp::carp($msg);
+
+    return 1;
+}
+
+sub _pp_child_error {
+    my $self    = shift;
+    my $cmd     = shift or return;
+    my $ce      = shift or return;
+    my $pp_cmd  = ref $cmd ? "@$cmd" : $cmd;
+
+
+    my $str;
+    if( $ce == -1 ) {
+        ### Include $! in the error message, so that the user can
+        ### see 'No such file or directory' versus 'Permission denied'
+        ### versus 'Cannot fork' or whatever the cause was.
+        $str = "Failed to execute '$pp_cmd': $!";
+
+    } elsif ( $ce & 127 ) {
+        ### some signal
+        $str = loc( "'%1' died with signal %2, %3 coredump",
+               $pp_cmd, ($ce & 127), ($ce & 128) ? 'with' : 'without');
+
+    } else {
+        ### Otherwise, the command run but gave error status.
+        $str = "'$pp_cmd' exited with value " . ($ce >> 8);
+    }
+
+    $self->_debug( "# Child error '$ce' translated to: $str" ) if $DEBUG;
+
+    return $str;
+}
+
+1;
+
+__END__
+
+=head2 $q = QUOTE
+
+Returns the character used for quoting strings on this platform. This is
+usually a C<'> (single quote) on most systems, but some systems use different
+quotes. For example, C<Win32> uses C<"> (double quote).
+
+You can use it as follows:
+
+  use IPC::Cmd qw[run QUOTE];
+  my $cmd = q[echo ] . QUOTE . q[foo bar] . QUOTE;
+
+This makes sure that C<foo bar> is treated as a string, rather than two
+separate arguments to the C<echo> function.
+
+=head1 HOW IT WORKS
+
+C<run> will try to execute your command using the following logic:
+
+=over 4
+
+=item *
+
+If you have C<IPC::Run> installed, and the variable C<$IPC::Cmd::USE_IPC_RUN>
+is set to true (See the L<"Global Variables"> section) use that to execute
+the command. You will have the full output available in buffers, interactive commands
+are sure to work  and you are guaranteed to have your verbosity
+settings honored cleanly.
+
+=item *
+
+Otherwise, if the variable C<$IPC::Cmd::USE_IPC_OPEN3> is set to true
+(See the L<"Global Variables"> section), try to execute the command using
+L<IPC::Open3>. Buffers will be available on all platforms,
+interactive commands will still execute cleanly, and also your verbosity
+settings will be adhered to nicely;
+
+=item *
+
+Otherwise, if you have the C<verbose> argument set to true, we fall back
+to a simple C<system()> call. We cannot capture any buffers, but
+interactive commands will still work.
+
+=item *
+
+Otherwise we will try and temporarily redirect STDERR and STDOUT, do a
+C<system()> call with your command and then re-open STDERR and STDOUT.
+This is the method of last resort and will still allow you to execute
+your commands cleanly. However, no buffers will be available.
+
+=back
+
+=head1 Global Variables
+
+The behaviour of IPC::Cmd can be altered by changing the following
+global variables:
+
+=head2 $IPC::Cmd::VERBOSE
+
+This controls whether IPC::Cmd will print any output from the
+commands to the screen or not. The default is 0.
+
+=head2 $IPC::Cmd::USE_IPC_RUN
+
+This variable controls whether IPC::Cmd will try to use L<IPC::Run>
+when available and suitable.
+
+=head2 $IPC::Cmd::USE_IPC_OPEN3
+
+This variable controls whether IPC::Cmd will try to use L<IPC::Open3>
+when available and suitable. Defaults to true.
+
+=head2 $IPC::Cmd::WARN
+
+This variable controls whether run-time warnings should be issued, like
+the failure to load an C<IPC::*> module you explicitly requested.
+
+Defaults to true. Turn this off at your own risk.
+
+=head2 $IPC::Cmd::INSTANCES
+
+This variable controls whether C<can_run> will return all instances of
+the binary it finds in the C<PATH> when called in a list context.
+
+Defaults to false, set to true to enable the described behaviour.
+
+=head2 $IPC::Cmd::ALLOW_NULL_ARGS
+
+This variable controls whether C<run> will remove any empty/null arguments
+it finds in command arguments.
+
+Defaults to false, so it will remove null arguments. Set to true to allow
+them.
+
+=head1 Caveats
+
+=over 4
+
+=item Whitespace and IPC::Open3 / system()
+
+When using C<IPC::Open3> or C<system>, if you provide a string as the
+C<command> argument, it is assumed to be appropriately escaped. You can
+use the C<QUOTE> constant to use as a portable quote character (see above).
+However, if you provide an array reference, special rules apply:
+
+If your command contains B<special characters> (< > | &), it will
+be internally stringified before executing the command, to avoid that these
+special characters are escaped and passed as arguments instead of retaining
+their special meaning.
+
+However, if the command contained arguments that contained whitespace,
+stringifying the command would lose the significance of the whitespace.
+Therefore, C<IPC::Cmd> will quote any arguments containing whitespace in your
+command if the command is passed as an arrayref and contains special characters.
+
+=item Whitespace and IPC::Run
+
+When using C<IPC::Run>, if you provide a string as the C<command> argument,
+the string will be split on whitespace to determine the individual elements
+of your command. Although this will usually just Do What You Mean, it may
+break if you have files or commands with whitespace in them.
+
+If you do not wish this to happen, you should provide an array
+reference, where all parts of your command are already separated out.
+Note however, if there are extra or spurious whitespaces in these parts,
+the parser or underlying code may not interpret it correctly, and
+cause an error.
+
+Example:
+The following code
+
+    gzip -cdf foo.tar.gz | tar -xf -
+
+should either be passed as
+
+    "gzip -cdf foo.tar.gz | tar -xf -"
+
+or as
+
+    ['gzip', '-cdf', 'foo.tar.gz', '|', 'tar', '-xf', '-']
+
+But take care not to pass it as, for example
+
+    ['gzip -cdf foo.tar.gz', '|', 'tar -xf -']
+
+Since this will lead to issues as described above.
+
+
+=item IO Redirect
+
+Currently it is too complicated to parse your command for IO
+redirections. For capturing STDOUT or STDERR there is a work around
+however, since you can just inspect your buffers for the contents.
+
+=item Interleaving STDOUT/STDERR
+
+Neither IPC::Run nor IPC::Open3 can interleave STDOUT and STDERR. For short
+bursts of output from a program, e.g. this sample,
+
+    for ( 1..4 ) {
+        $_ % 2 ? print STDOUT $_ : print STDERR $_;
+    }
+
+IPC::[Run|Open3] will first read all of STDOUT, then all of STDERR, meaning
+the output looks like '13' on STDOUT and '24' on STDERR, instead of
+
+    1
+    2
+    3
+    4
+
+This has been recorded in L<rt.cpan.org> as bug #37532: Unable to interleave
+STDOUT and STDERR.
+
+=back
+
+=head1 See Also
+
+L<IPC::Run>, L<IPC::Open3>
+
+=head1 ACKNOWLEDGEMENTS
+
+Thanks to James Mastros and Martijn van der Streek for their
+help in getting L<IPC::Open3> to behave nicely.
+
+Thanks to Petya Kohts for the C<run_forked> code.
+
+=head1 BUG REPORTS
+
+Please report bugs or other issues to E<lt>bug-ipc-cmd@rt.cpan.orgE<gt>.
+
+=head1 AUTHOR
+
+Original author: Jos Boumans E<lt>kane@cpan.orgE<gt>.
+Current maintainer: Chris Williams E<lt>bingos@cpan.orgE<gt>.
+
+=head1 COPYRIGHT
+
+This library is free software; you may redistribute and/or modify it
+under the same terms as Perl itself.
+
+=cut

git/usr/share/perl5/core_perl/IPC/Open2.pm

@@ -0,0 +1,173 @@
+package IPC::Open2;
+
+use strict;
+
+require 5.006;
+use Exporter 'import';
+
+our $VERSION = 1.08;
+our @EXPORT  = qw(open2);
+
+=head1 NAME
+
+IPC::Open2 - open a process for both reading and writing using open2()
+
+=head1 SYNOPSIS
+
+    use IPC::Open2;
+
+    my $pid = open2(my $chld_out, my $chld_in,
+      'some', 'cmd', 'and', 'args');
+    # or passing the command through the shell
+    my $pid = open2(my $chld_out, my $chld_in, 'some cmd and args');
+
+    # read from parent STDIN and write to already open handle
+    open my $outfile, '>', 'outfile.txt' or die "open failed: $!";
+    my $pid = open2(['&', $outfile], ['&', *STDIN],
+      'some', 'cmd', 'and', 'args');
+
+    # read from already open handle and write to parent STDOUT
+    open my $infile, '<', 'infile.txt' or die "open failed: $!";
+    my $pid = open2(['&', *STDOUT], ['&', $infile],
+      'some', 'cmd', 'and', 'args');
+
+    # reap zombie and retrieve exit status
+    waitpid( $pid, 0 );
+    my $child_exit_status = $? >> 8;
+
+=head1 DESCRIPTION
+
+The C<open2()> function runs the given command and connects C<$chld_out> for
+reading and C<$chld_in> for writing.  It's what you think should work
+when you try
+
+    my $pid = open(my $fh, "|cmd args|");  # ERROR
+
+but you have to write it as:
+
+    my $pid = open2($chld_out, $chld_in, @command_and_args);
+
+The C<$chld_in> filehandle will have autoflush turned on.
+
+By default, the filehandles you pass in are used as output parameters.
+C<open2> internally creates two pipes.  The write end of the first pipe and the
+read end of the second pipe are connected to the command's standard output and
+input, respectively.  The corresponding read and write ends are placed in the
+first and second argument to C<open2>.
+
+The filehandle arguments can take the following forms:
+
+=over
+
+=item *
+
+An uninitialized variable (technically, either C<undef> or the empty string
+will work):  C<open2> generates a fresh filehandle and assigns it to the
+argument, which must be a modifiable variable for this work (otherwise an
+exception will be raised).
+
+=item *
+
+An existing handle in the form of a typeglob like C<*STDIN> or C<*FOO> or a
+reference to such:  C<open2> places the filehandle in the C<IO> slot of the
+typeglob, which means the corresponding bareword filehandle (like C<STDIN> or
+C<FOO>) can be used for I/O from/to the child process.  (If the handle is
+already open, it is automatically closed first.)
+
+=item *
+
+A string containing the name of a bareword handle (like C<'STDIN'> or
+C<'FOO'>):  Such strings are resolved to typeglobs at runtime and then act like
+the case described above.
+
+=back
+
+However, it is possible to make C<open2> use an existing handle directly (as an
+input argument) and skip the creation of a pipe.  To do this, the filehandle
+argument must have one of the following two forms:
+
+=over
+
+=item *
+
+An array reference like C<['&', $fh]>, i.e. the first element is the string
+C<'&'> and the second element is the existing handle to use in the child
+process.
+
+=item *
+
+A string of the form C<< '<&FOO' >> or C<< '>&FOO' >>, i.e. a string starting
+with the two characters C<< <& >> (for input) or C<< >& >> (for output),
+followed by the name of a bareword filehandle.  (The string form cannot be used
+with handles stored in variables.)
+
+=back
+
+If you use this form for C<$chld_in>, the filehandle will be closed in the
+parent process.
+
+C<open2> returns the process ID of the child process.  It doesn't return on
+failure: it just raises an exception matching C</^open2:/>.  However,
+C<exec> failures in the child are not detected.  You'll have to
+trap SIGPIPE yourself.
+
+C<open2> does not wait for and reap the child process after it exits.
+Except for short programs where it's acceptable to let the operating system
+take care of this, you need to do this yourself.  This is normally as
+simple as calling C<waitpid $pid, 0> when you're done with the process.
+Failing to do this can result in an accumulation of defunct or "zombie"
+processes.  See L<perlfunc/waitpid> for more information.
+
+This whole affair is quite dangerous, as you may block forever.  It
+assumes it's going to talk to something like L<bc(1)>, both writing
+to it and reading from it.  This is presumably safe because you
+"know" that commands like L<bc(1)> will read a line at a time and
+output a line at a time.  Programs like L<sort(1)> that read their
+entire input stream first, however, are quite apt to cause deadlock.
+
+The big problem with this approach is that if you don't have control 
+over source code being run in the child process, you can't control
+what it does with pipe buffering.  Thus you can't just open a pipe to
+C<cat -v> and continually read and write a line from it.
+
+The L<IO::Pty> and L<Expect> modules from CPAN can help with this, as
+they provide a real tty (well, a pseudo-tty, actually), which gets you
+back to line buffering in the invoked command again.
+
+=head1 WARNING 
+
+The order of arguments differs from that of C<open3> from L<IPC::Open3>.
+
+=head1 SEE ALSO
+
+See L<IPC::Open3> for an alternative that handles C<STDERR> as well.  This
+function is really just a wrapper around C<open3>.
+
+=cut
+
+# &open2: tom christiansen, <tchrist@convex.com>
+#
+# usage: $pid = open2('rdr', 'wtr', 'some cmd and args');
+#    or  $pid = open2('rdr', 'wtr', 'some', 'cmd', 'and', 'args');
+#
+# spawn the given $cmd and connect $rdr for
+# reading and $wtr for writing.  return pid
+# of child, or 0 on failure.  
+# 
+# WARNING: this is dangerous, as you may block forever
+# unless you are very careful.  
+# 
+# $wtr is left unbuffered.
+# 
+# abort program if
+#	rdr or wtr are null
+# 	a system call fails
+
+require IPC::Open3;
+
+sub open2 {
+    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+    return IPC::Open3::_open3('open2', $_[1], $_[0], '>&STDERR', @_[2 .. $#_]);
+}
+
+1

git/usr/share/perl5/core_perl/IPC/Open3.pm

@@ -0,0 +1,507 @@
+package IPC::Open3;
+
+use strict;
+no strict 'refs'; # because users pass me bareword filehandles
+
+use Exporter 'import';
+
+use Carp;
+use Symbol qw(gensym qualify);
+
+our $VERSION = '1.24';
+our @EXPORT  = qw(open3);
+
+=head1 NAME
+
+IPC::Open3 - open a process for reading, writing, and error handling using open3()
+
+=head1 SYNOPSIS
+
+    use Symbol 'gensym'; # vivify a separate handle for STDERR
+    my $pid = open3(my $chld_in, my $chld_out, my $chld_err = gensym,
+		    'some', 'cmd', 'and', 'args');
+    # or pass the command through the shell
+    my $pid = open3(my $chld_in, my $chld_out, my $chld_err = gensym,
+		    'some cmd and args');
+
+    # read from parent STDIN
+    # send STDOUT and STDERR to already open handle
+    open my $outfile, '>>', 'output.txt' or die "open failed: $!";
+    my $pid = open3(['&', *STDIN], ['&', $outfile], undef,
+		    'some', 'cmd', 'and', 'args');
+
+    # write to parent STDOUT and STDERR
+    my $pid = open3(my $chld_in, ['&', *STDOUT], ['&', *STDERR],
+		    'some', 'cmd', 'and', 'args');
+
+    # reap zombie and retrieve exit status
+    waitpid( $pid, 0 );
+    my $child_exit_status = $? >> 8;
+
+=head1 DESCRIPTION
+
+Extremely similar to C<open2> from L<IPC::Open2>, C<open3> spawns the given
+command and provides filehandles for interacting with the command's standard
+I/O streams.
+
+    my $pid = open3($chld_in, $chld_out, $chld_err, @command_and_args);
+
+It connects C<$chld_in> for writing to the child's standard input, C<$chld_out>
+for reading from the child's standard output, and C<$chld_err> for reading from
+the child's standard error stream.  If C<$chld_err> is false, or the same file
+descriptor as C<$chld_out>, then C<STDOUT> and C<STDERR> of the child are on
+the same filehandle.  This means that you cannot pass an uninitialized variable
+for C<$chld_err> and have C<open3> auto-generate a filehandle for you, but
+gensym from L<Symbol> can be used to vivify a new glob reference; see
+L</SYNOPSIS>.  The C<$chld_in> handle will have autoflush turned on.
+
+By default, the filehandles you pass in are used as output parameters.
+C<open3> internally creates three pipes.  The write end of the first pipe and
+the read ends of the other pipes are connected to the command's standard
+input/output/error, respectively.  The corresponding read and write ends are
+placed in the first three argument to C<open3>.
+
+The filehandle arguments can take the following forms:
+
+=over
+
+=item *
+
+An uninitialized variable (technically, either C<undef> or the empty string
+will work):  C<open3> generates a fresh filehandle and assigns it to the
+argument, which must be a modifiable variable for this work (otherwise an
+exception will be raised).
+
+This does not work for C<$chld_err>, however:  If the C<$chld_err> argument is
+a false value, the child's error stream is automatically redirected to its
+standard output.
+
+=item *
+
+An existing handle in the form of a typeglob like C<*STDIN> or C<*FOO> or a
+reference to such:  C<open3> places the filehandle in the C<IO> slot of the
+typeglob, which means the corresponding bareword filehandle (like C<STDIN> or
+C<FOO>) can be used for I/O from/to the child process.  (If the handle is
+already open, it is automatically closed first.)
+
+=item *
+
+A string containing the name of a bareword handle (like C<'STDIN'> or
+C<'FOO'>):  Such strings are resolved to typeglobs at runtime and then act like
+the case described above.
+
+=back
+
+However, it is possible to make C<open3> use an existing handle directly (as an
+input argument) and skip the creation of a pipe.  To do this, the filehandle
+argument must have one of the following two forms:
+
+=over
+
+=item *
+
+An array reference like C<['&', $fh]>, i.e. the first element is the string
+C<'&'> and the second element is the existing handle to use in the child
+process.
+
+=item *
+
+A string of the form C<< '<&FOO' >> or C<< '>&FOO' >>, i.e. a string starting
+with the two characters C<< <& >> (for input) or C<< >& >> (for output),
+followed by the name of a bareword filehandle.  (The string form cannot be used
+with handles stored in variables.)
+
+=back
+
+If you use this form for C<$chld_in>, the filehandle will be closed in the
+parent process.
+
+The filehandles may also be integers, in which case they are understood
+as file descriptors.
+
+C<open3> returns the process ID of the child process.  It doesn't return on
+failure: it just raises an exception matching C</^open3:/>.  However,
+C<exec> failures in the child (such as no such file or permission denied),
+are just reported to C<$chld_err> under Windows and OS/2, as it is not possible
+to trap them.
+
+If the child process dies for any reason, the next write to C<$chld_in> is
+likely to generate a SIGPIPE in the parent, which is fatal by default,
+So you may wish to handle this signal.
+
+Note: if you specify C<-> as the command, in an analogous fashion to
+C<open(my $fh, "-|")> the child process will just be the forked Perl
+process rather than an external command.  This feature isn't yet
+supported on Win32 platforms.
+
+C<open3> does not wait for and reap the child process after it exits.
+Except for short programs where it's acceptable to let the operating system
+take care of this, you need to do this yourself.  This is normally as
+simple as calling C<waitpid $pid, 0> when you're done with the process.
+Failing to do this can result in an accumulation of defunct or "zombie"
+processes.  See L<perlfunc/waitpid> for more information.
+
+If you try to read from the child's stdout writer and their stderr
+writer, you'll have problems with blocking, which means you'll want
+to use C<select> or L<IO::Select>, which means you'd best use
+C<sysread> instead of C<readline> for normal stuff.
+
+This is very dangerous, as you may block forever.  C<open3> assumes it's
+going to talk to something like L<bc(1)>, both writing to it and reading
+from it.  This is presumably safe because you "know" that commands
+like L<bc(1)> will read a line at a time and output a line at a time.
+Programs like L<sort(1)> that read their entire input stream first,
+however, are quite apt to cause deadlock.
+
+The big problem with this approach is that if you don't have control
+over source code being run in the child process, you can't control
+what it does with pipe buffering.  Thus you can't just open a pipe to
+C<cat -v> and continually read and write a line from it.
+
+=head1 See Also
+
+=over 4
+
+=item L<IPC::Open2>
+
+Like L<IPC::Open3> but without C<STDERR> capture.
+
+=item L<IPC::Run>
+
+This is a CPAN module that has better error handling and more facilities
+than L<IPC::Open3>.
+
+=back
+
+=head1 WARNING
+
+The order of arguments differs from that of C<open2>.
+
+=cut
+
+# &open3: Marc Horowitz <marc@mit.edu>
+# derived mostly from &open2 by tom christiansen, <tchrist@convex.com>
+# fixed for 5.001 by Ulrich Kunitz <kunitz@mai-koeln.com>
+# ported to Win32 by Ron Schmidt, Merrill Lynch almost ended my career
+# fixed for autovivving FHs, tchrist again
+# allow fd numbers to be used, by Frank Tobin
+# allow '-' as command (c.f. open "-|"), by Adam Spiers <perl@adamspiers.org>
+#
+# usage: $pid = open3('wtr', 'rdr', 'err' 'some cmd and args', 'optarg', ...);
+#
+# spawn the given $cmd and connect rdr for
+# reading, wtr for writing, and err for errors.
+# if err is '', or the same as rdr, then stdout and
+# stderr of the child are on the same fh.  returns pid
+# of child (or dies on failure).
+
+
+# if wtr begins with '<&', then wtr will be closed in the parent, and
+# the child will read from it directly.  if rdr or err begins with
+# '>&', then the child will send output directly to that fd.  In both
+# cases, there will be a dup() instead of a pipe() made.
+
+
+# WARNING: this is dangerous, as you may block forever
+# unless you are very careful.
+#
+# $wtr is left unbuffered.
+#
+# abort program if
+#   rdr or wtr are null
+#   a system call fails
+
+our $Me = 'open3 (bug)';	# you should never see this, it's always localized
+
+# Fatal.pm needs to be fixed WRT prototypes.
+
+sub xpipe {
+    pipe $_[0], $_[1] or croak "$Me: pipe($_[0], $_[1]) failed: $!";
+}
+
+# I tried using a * prototype character for the filehandle but it still
+# disallows a bareword while compiling under strict subs.
+
+sub xopen {
+    open $_[0], $_[1], @_[2..$#_] and return;
+    local $" = ', ';
+    carp "$Me: open(@_) failed: $!";
+}
+
+sub xclose {
+    $_[0] =~ /\A=?(\d+)\z/
+	? do { my $fh; open($fh, $_[1] . '&=' . $1) and close($fh); }
+	: close $_[0]
+	or croak "$Me: close($_[0]) failed: $!";
+}
+
+sub xfileno {
+    return $1 if $_[0] =~ /\A=?(\d+)\z/;  # deal with fh just being an fd
+    return fileno $_[0];
+}
+
+use constant FORCE_DEBUG_SPAWN => 0;
+use constant DO_SPAWN => $^O eq 'os2' || $^O eq 'MSWin32' || FORCE_DEBUG_SPAWN;
+
+sub _open3 {
+    local $Me = shift;
+
+    # simulate autovivification of filehandles because
+    # it's too ugly to use @_ throughout to make perl do it for us
+    # tchrist 5-Mar-00
+
+    # Historically, open3(undef...) has silently worked, so keep
+    # it working.
+    splice @_, 0, 1, undef if \$_[0] == \undef;
+    splice @_, 1, 1, undef if \$_[1] == \undef;
+    unless (eval  {
+	$_[0] = gensym unless defined $_[0] && length $_[0];
+	$_[1] = gensym unless defined $_[1] && length $_[1];
+	1; })
+    {
+	# must strip crud for croak to add back, or looks ugly
+	$@ =~ s/(?<=value attempted) at .*//s;
+	croak "$Me: $@";
+    }
+
+    my @handles = ({ mode => '<', handle => \*STDIN },
+		   { mode => '>', handle => \*STDOUT },
+		   { mode => '>', handle => \*STDERR },
+		  );
+
+    foreach (@handles) {
+	$_->{parent} = shift;
+	$_->{open_as} = gensym;
+    }
+
+    if (@_ > 1 and $_[0] eq '-') {
+	croak "Arguments don't make sense when the command is '-'"
+    }
+
+    $handles[2]{parent} ||= $handles[1]{parent};
+    $handles[2]{dup_of_out} = $handles[1]{parent} eq $handles[2]{parent};
+
+    my $package;
+    foreach (@handles) {
+        if (ref($_->{parent}) eq 'ARRAY') {
+            if ($_->{parent}[0] eq '&') {
+                $_->{dup} = 1;
+                $_->{parent} = $_->{parent}[1];
+            } else {
+                croak "$Me: Invalid dup mode: $_->{parent}[0]";
+            }
+        } else {
+            $_->{dup} = ($_->{parent} =~ s/^[<>]&//);
+
+            if ($_->{parent} !~ /\A=?(\d+)\z/) {
+                # force unqualified filehandles into caller's package
+                $package //= caller 1;
+                $_->{parent} = qualify $_->{parent}, $package;
+            }
+
+            next if $_->{dup} or $_->{dup_of_out};
+            if ($_->{mode} eq '<') {
+                xpipe $_->{open_as}, $_->{parent};
+            } else {
+                xpipe $_->{parent}, $_->{open_as};
+            }
+        }
+    }
+
+    my $kidpid;
+    if (!DO_SPAWN) {
+	# Used to communicate exec failures.
+	xpipe my $stat_r, my $stat_w;
+
+	$kidpid = fork;
+	croak "$Me: fork failed: $!" unless defined $kidpid;
+	if ($kidpid == 0) {  # Kid
+	    eval {
+		# A tie in the parent should not be allowed to cause problems.
+		untie *STDIN;
+		untie *STDOUT;
+		untie *STDERR;
+
+		close $stat_r;
+		require Fcntl;
+		my $flags = fcntl $stat_w, &Fcntl::F_GETFD, 0;
+		croak "$Me: fcntl failed: $!" unless $flags;
+		fcntl $stat_w, &Fcntl::F_SETFD, $flags|&Fcntl::FD_CLOEXEC
+		    or croak "$Me: fcntl failed: $!";
+
+		# If she wants to dup the kid's stderr onto her stdout I need to
+		# save a copy of her stdout before I put something else there.
+		if (!$handles[2]{dup_of_out} && $handles[2]{dup}
+			&& xfileno($handles[2]{parent}) == fileno \*STDOUT) {
+		    my $tmp = gensym;
+		    xopen($tmp, '>&', $handles[2]{parent});
+		    $handles[2]{parent} = $tmp;
+		}
+
+		foreach (@handles) {
+		    if ($_->{dup_of_out}) {
+			xopen \*STDERR, '>&', *STDOUT
+			    if defined fileno STDERR && fileno STDERR != fileno STDOUT;
+		    } elsif ($_->{dup}) {
+			xopen $_->{handle}, $_->{mode} . '&', $_->{parent}
+			    if fileno $_->{handle} != xfileno($_->{parent});
+		    } else {
+			xclose $_->{parent}, $_->{mode};
+			xopen $_->{handle}, $_->{mode} . '&=',
+			    fileno $_->{open_as};
+		    }
+		}
+		return 1 if ($_[0] eq '-');
+		exec @_ or do {
+		    local($")=(" ");
+		    croak "$Me: exec of @_ failed: $!";
+		};
+	    } and do {
+                close $stat_w;
+                return 0;
+            };
+
+	    my $bang = 0+$!;
+	    my $err = $@;
+	    utf8::encode $err if $] >= 5.008;
+	    print $stat_w pack('IIa*', $bang, length($err), $err);
+	    close $stat_w;
+
+	    eval { require POSIX; POSIX::_exit(255); };
+	    exit 255;
+	}
+	else {  # Parent
+	    close $stat_w;
+	    my $to_read = length(pack('I', 0)) * 2;
+	    my $bytes_read = read($stat_r, my $buf = '', $to_read);
+	    if ($bytes_read) {
+		(my $bang, $to_read) = unpack('II', $buf);
+		read($stat_r, my $err = '', $to_read);
+		waitpid $kidpid, 0; # Reap child which should have exited
+		if ($err) {
+		    utf8::decode $err if $] >= 5.008;
+		} else {
+		    $err = "$Me: " . ($! = $bang);
+		}
+		$! = $bang;
+		die($err);
+	    }
+	}
+    }
+    else {  # DO_SPAWN
+	# All the bookkeeping of coincidence between handles is
+	# handled in spawn_with_handles.
+
+	my @close;
+
+	foreach (@handles) {
+	    if ($_->{dup_of_out}) {
+		$_->{open_as} = $handles[1]{open_as};
+	    } elsif ($_->{dup}) {
+		$_->{open_as} = $_->{parent} =~ /\A[0-9]+\z/
+		    ? $_->{parent} : \*{$_->{parent}};
+		push @close, $_->{open_as};
+	    } else {
+		push @close, \*{$_->{parent}}, $_->{open_as};
+	    }
+	}
+	require IO::Pipe;
+	$kidpid = eval {
+	    spawn_with_handles(\@handles, \@close, @_);
+	};
+	die "$Me: $@" if $@;
+    }
+
+    foreach (@handles) {
+	next if $_->{dup} or $_->{dup_of_out};
+	xclose $_->{open_as}, $_->{mode};
+    }
+
+    # If the write handle is a dup give it away entirely, close my copy
+    # of it.
+    xclose $handles[0]{parent}, $handles[0]{mode} if $handles[0]{dup};
+
+    select((select($handles[0]{parent}), $| = 1)[0]); # unbuffer pipe
+    $kidpid;
+}
+
+sub open3 {
+    if (@_ < 4) {
+	local $" = ', ';
+	croak "open3(@_): not enough arguments";
+    }
+    return _open3 'open3', @_
+}
+
+sub spawn_with_handles {
+    my $fds = shift;		# Fields: handle, mode, open_as
+    my $close_in_child = shift;
+    my ($fd, %saved, @errs);
+
+    foreach $fd (@$fds) {
+	$fd->{tmp_copy} = IO::Handle->new_from_fd($fd->{handle}, $fd->{mode});
+	$saved{fileno $fd->{handle}} = $fd->{tmp_copy} if $fd->{tmp_copy};
+    }
+    foreach $fd (@$fds) {
+	bless $fd->{handle}, 'IO::Handle'
+	    unless eval { $fd->{handle}->isa('IO::Handle') } ;
+	# If some of handles to redirect-to coincide with handles to
+	# redirect, we need to use saved variants:
+    my $open_as = $fd->{open_as};
+    my $fileno = fileno($open_as);
+    $fd->{handle}->fdopen(defined($fileno)
+                  ? $saved{$fileno} || $open_as
+                  : $open_as,
+                  $fd->{mode});
+    }
+    unless ($^O eq 'MSWin32') {
+	require Fcntl;
+	# Stderr may be redirected below, so we save the err text:
+	foreach $fd (@$close_in_child) {
+	    next unless fileno $fd;
+	    fcntl($fd, Fcntl::F_SETFD(), 1) or push @errs, "fcntl $fd: $!"
+		unless $saved{fileno $fd}; # Do not close what we redirect!
+	}
+    }
+
+    my $pid;
+    unless (@errs) {
+	if (FORCE_DEBUG_SPAWN) {
+	    pipe my $r, my $w or die "Pipe failed: $!";
+	    $pid = fork;
+	    die "Fork failed: $!" unless defined $pid;
+	    if (!$pid) {
+		{ no warnings; exec @_ }
+		print $w 0 + $!;
+		close $w;
+		require POSIX;
+		POSIX::_exit(255);
+	    }
+	    close $w;
+	    my $bad = <$r>;
+	    if (defined $bad) {
+		$! = $bad;
+		undef $pid;
+	    }
+	} else {
+	    $pid = eval { system 1, @_ }; # 1 == P_NOWAIT
+	}
+	if($@) {
+	    push @errs, "IO::Pipe: Can't spawn-NOWAIT: $@";
+	} elsif(!$pid || $pid < 0) {
+	    push @errs, "IO::Pipe: Can't spawn-NOWAIT: $!";
+	}
+    }
+
+    # Do this in reverse, so that STDERR is restored first:
+    foreach $fd (reverse @$fds) {
+	$fd->{handle}->fdopen($fd->{tmp_copy}, $fd->{mode});
+    }
+    foreach (values %saved) {
+	$_->close or croak "Can't close: $!";
+    }
+    croak join "\n", @errs if @errs;
+    return $pid;
+}
+
+1; # so require is happy

git/usr/share/perl5/core_perl/Math/Complex.pm

@@ -0,0 +1,2138 @@
+#
+# Complex numbers and associated mathematical functions
+# -- Raphael Manfredi	Since Sep 1996
+# -- Jarkko Hietaniemi	Since Mar 1997
+# -- Daniel S. Lewart	Since Sep 1997
+#
+
+package Math::Complex;
+
+{ use 5.006; }
+use strict;
+
+our $VERSION = 1.63;
+
+use Config;
+
+our ($Inf, $ExpInf);
+our ($vax_float, $has_inf, $has_nan);
+
+BEGIN {
+    $vax_float = (pack("d",1) =~ /^[\x80\x10]\x40/);
+    $has_inf   = !$vax_float;
+    $has_nan   = !$vax_float;
+
+    unless ($has_inf) {
+      # For example in vax, there is no Inf,
+      # and just mentioning the DBL_MAX (1.70141183460469229e+38)
+      # causes SIGFPE.
+
+      # These are pretty useless without a real infinity,
+      # but setting them makes for less warnings about their
+      # undefined values.
+      $Inf = "Inf";
+      $ExpInf = "Inf";
+      return;
+    }
+
+    my %DBL_MAX =  # These are IEEE 754 maxima.
+	(
+	  4  => '1.70141183460469229e+38',
+	  8  => '1.7976931348623157e+308',
+	 # AFAICT the 10, 12, and 16-byte long doubles
+	 # all have the same maximum.
+	 10 => '1.1897314953572317650857593266280070162E+4932',
+	 12 => '1.1897314953572317650857593266280070162E+4932',
+	 16 => '1.1897314953572317650857593266280070162E+4932',
+	);
+
+    my $nvsize = $Config{nvsize} ||
+	        ($Config{uselongdouble} && $Config{longdblsize}) ||
+                 $Config{doublesize};
+    die "Math::Complex: Could not figure out nvsize\n"
+	unless defined $nvsize;
+    die "Math::Complex: Cannot not figure out max nv (nvsize = $nvsize)\n"
+	unless defined $DBL_MAX{$nvsize};
+    my $DBL_MAX = eval $DBL_MAX{$nvsize};
+    die "Math::Complex: Could not figure out max nv (nvsize = $nvsize)\n"
+	unless defined $DBL_MAX;
+    my $BIGGER_THAN_THIS = 1e30;  # Must find something bigger than this.
+    if ($^O eq 'unicosmk') {
+	$Inf = $DBL_MAX;
+    } else {
+	local $SIG{FPE} = sub { };
+        local $!;
+	# We do want an arithmetic overflow, Inf INF inf Infinity.
+	for my $t (
+	    'exp(99999)',  # Enough even with 128-bit long doubles.
+	    'inf',
+	    'Inf',
+	    'INF',
+	    'infinity',
+	    'Infinity',
+	    'INFINITY',
+	    '1e99999',
+	    ) {
+	    local $^W = 0;
+	    my $i = eval "$t+1.0";
+	    if (defined $i && $i > $BIGGER_THAN_THIS) {
+		$Inf = $i;
+		last;
+	    }
+          }
+	$Inf = $DBL_MAX unless defined $Inf;  # Oh well, close enough.
+	die "Math::Complex: Could not get Infinity"
+	    unless $Inf > $BIGGER_THAN_THIS;
+	$ExpInf = eval 'exp(99999)';
+      }
+    # print "# On this machine, Inf = '$Inf'\n";
+}
+
+use Scalar::Util qw(set_prototype);
+
+use warnings;
+no warnings 'syntax';  # To avoid the (_) warnings.
+
+BEGIN {
+    # For certain functions that we override, in 5.10 or better
+    # we can set a smarter prototype that will handle the lexical $_
+    # (also a 5.10+ feature).
+    if ($] >= 5.010000) {
+        set_prototype \&abs, '_';
+        set_prototype \&cos, '_';
+        set_prototype \&exp, '_';
+        set_prototype \&log, '_';
+        set_prototype \&sin, '_';
+        set_prototype \&sqrt, '_';
+    }
+}
+
+my $i;
+my %LOGN;
+
+# Regular expression for floating point numbers.
+# These days we could use Scalar::Util::lln(), I guess.
+my $gre = qr'\s*([\+\-]?(?:(?:(?:\d+(?:_\d+)*(?:\.\d*(?:_\d+)*)?|\.\d+(?:_\d+)*)(?:[eE][\+\-]?\d+(?:_\d+)*)?)|inf))'i;
+
+require Exporter;
+
+our @ISA = qw(Exporter);
+
+my @trig = qw(
+	      pi
+	      tan
+	      csc cosec sec cot cotan
+	      asin acos atan
+	      acsc acosec asec acot acotan
+	      sinh cosh tanh
+	      csch cosech sech coth cotanh
+	      asinh acosh atanh
+	      acsch acosech asech acoth acotanh
+	     );
+
+our @EXPORT = (qw(
+	     i Re Im rho theta arg
+	     sqrt log ln
+	     log10 logn cbrt root
+	     cplx cplxe
+	     atan2
+	     ),
+	   @trig);
+
+my @pi = qw(pi pi2 pi4 pip2 pip4 Inf);
+
+our @EXPORT_OK = @pi;
+
+our %EXPORT_TAGS = (
+    'trig' => [@trig],
+    'pi' => [@pi],
+);
+
+use overload
+	'='	=> \&_copy,
+	'+='	=> \&_plus,
+	'+'	=> \&_plus,
+	'-='	=> \&_minus,
+	'-'	=> \&_minus,
+	'*='	=> \&_multiply,
+	'*'	=> \&_multiply,
+	'/='	=> \&_divide,
+	'/'	=> \&_divide,
+	'**='	=> \&_power,
+	'**'	=> \&_power,
+	'=='	=> \&_numeq,
+	'<=>'	=> \&_spaceship,
+	'neg'	=> \&_negate,
+	'~'	=> \&_conjugate,
+	'abs'	=> \&abs,
+	'sqrt'	=> \&sqrt,
+	'exp'	=> \&exp,
+	'log'	=> \&log,
+	'sin'	=> \&sin,
+	'cos'	=> \&cos,
+	'atan2'	=> \&atan2,
+        '""'    => \&_stringify;
+
+#
+# Package "privates"
+#
+
+my %DISPLAY_FORMAT = ('style' => 'cartesian',
+		      'polar_pretty_print' => 1);
+my $eps            = 1e-14;		# Epsilon
+
+#
+# Object attributes (internal):
+#	cartesian	[real, imaginary] -- cartesian form
+#	polar		[rho, theta] -- polar form
+#	c_dirty		cartesian form not up-to-date
+#	p_dirty		polar form not up-to-date
+#	display		display format (package's global when not set)
+#
+
+# Die on bad *make() arguments.
+
+sub _cannot_make {
+    die "@{[(caller(1))[3]]}: Cannot take $_[0] of '$_[1]'.\n";
+}
+
+sub _normalize_num {
+    my $x = shift;
+    $x =~ s/^\+//;
+    $x =~ s/_//g;
+    $x =~ s/^(-?)inf$/$1 ? -Inf() : Inf()/ie if $has_inf;
+    return $x;
+}
+
+sub _make {
+    my $arg = shift;
+    my ($p, $q);
+
+    if ($arg =~ /^$gre$/) {
+	($p, $q) = ($1, 0);
+    } elsif ($arg =~ /^(?:$gre(?=\s*[+\-]))?$gre\s*i\s*$/) {
+	($p, $q) = ($1 || 0, $2);
+    } elsif ($arg =~ /^(?:$gre(?=\s*[+\-]))?\s*([+\-]?)i\s*$/) {
+        ($p, $q) = ($1 || 0, $2 . '1');
+    } elsif ($arg =~ /^\s*\($gre\s*(?:,$gre\s*)?\)\s*$/) {
+	($p, $q) = ($1, $2 || 0);
+    }
+
+    if (defined $p) {
+	$p = _normalize_num $p;
+	$q = _normalize_num $q;
+    }
+
+    return ($p, $q);
+}
+
+sub _emake {
+    my $arg = shift;
+    my ($p, $q);
+
+    if ($arg =~ /^\s*\[$gre\s*(?:,$gre\s*)?\]\s*$/) {
+	($p, $q) = ($1, $2 || 0);
+    } elsif ($arg =~ m!^\s*\[$gre\s*(?:,\s*([-+]?\d*\s*)?pi(?:/\s*(\d+))?\s*)?\]\s*$!) {
+	($p, $q) = ($1, ($2 eq '-' ? -1 : ($2 || 1)) * pi() / ($3 || 1));
+    } elsif ($arg =~ /^\s*\[$gre\s*\]\s*$/) {
+	($p, $q) = ($1, 0);
+    } elsif ($arg =~ /^$gre\s*$/) {
+	($p, $q) = ($1, 0);
+    }
+
+    if (defined $p) {
+        $p = _normalize_num $p;
+        $q = _normalize_num $q;
+    }
+
+    return ($p, $q);
+}
+
+sub _copy {
+    my $self = shift;
+    my $clone = {%$self};
+    if ($self->{'cartesian'}) {
+	$clone->{'cartesian'} = [@{$self->{'cartesian'}}];
+    }
+    if ($self->{'polar'}) {
+	$clone->{'polar'} = [@{$self->{'polar'}}];
+    }
+    bless $clone,__PACKAGE__;
+    return $clone;
+}
+
+#
+# ->make
+#
+# Create a new complex number (cartesian form)
+#
+sub make {
+    my $self = bless {}, shift;
+    my ($re, $im);
+    if (@_ == 0) {
+	($re, $im) = (0, 0);
+    } elsif (@_ == 1) {
+	return (ref $self)->emake($_[0])
+	    if ($_[0] =~ /^\s*\[/);
+	($re, $im) = _make($_[0]);
+    } elsif (@_ == 2) {
+	($re, $im) = @_;
+    }
+    if (defined $re) {
+	_cannot_make("real part",      $re) unless $re =~ /^$gre$/;
+    }
+    $im ||= 0;
+    _cannot_make("imaginary part", $im) unless $im =~ /^$gre$/;
+    $self->_set_cartesian([$re, $im ]);
+    $self->display_format('cartesian');
+
+    return $self;
+}
+
+#
+# ->emake
+#
+# Create a new complex number (exponential form)
+#
+sub emake {
+    my $self = bless {}, shift;
+    my ($rho, $theta);
+    if (@_ == 0) {
+	($rho, $theta) = (0, 0);
+    } elsif (@_ == 1) {
+	return (ref $self)->make($_[0])
+	    if ($_[0] =~ /^\s*\(/ || $_[0] =~ /i\s*$/);
+	($rho, $theta) = _emake($_[0]);
+    } elsif (@_ == 2) {
+	($rho, $theta) = @_;
+    }
+    if (defined $rho && defined $theta) {
+	if ($rho < 0) {
+	    $rho   = -$rho;
+	    $theta = ($theta <= 0) ? $theta + pi() : $theta - pi();
+	}
+    }
+    if (defined $rho) {
+	_cannot_make("rho",   $rho)   unless $rho   =~ /^$gre$/;
+    }
+    $theta ||= 0;
+    _cannot_make("theta", $theta) unless $theta =~ /^$gre$/;
+    $self->_set_polar([$rho, $theta]);
+    $self->display_format('polar');
+
+    return $self;
+}
+
+sub new { &make }		# For backward compatibility only.
+
+#
+# cplx
+#
+# Creates a complex number from a (re, im) tuple.
+# This avoids the burden of writing Math::Complex->make(re, im).
+#
+sub cplx {
+	return __PACKAGE__->make(@_);
+}
+
+#
+# cplxe
+#
+# Creates a complex number from a (rho, theta) tuple.
+# This avoids the burden of writing Math::Complex->emake(rho, theta).
+#
+sub cplxe {
+	return __PACKAGE__->emake(@_);
+}
+
+#
+# pi
+#
+# The number defined as pi = 180 degrees
+#
+sub pi () { 4 * CORE::atan2(1, 1) }
+
+#
+# pi2
+#
+# The full circle
+#
+sub pi2 () { 2 * pi }
+
+#
+# pi4
+#
+# The full circle twice.
+#
+sub pi4 () { 4 * pi }
+
+#
+# pip2
+#
+# The quarter circle
+#
+sub pip2 () { pi / 2 }
+
+#
+# pip4
+#
+# The eighth circle.
+#
+sub pip4 () { pi / 4 }
+
+#
+# _uplog10
+#
+# Used in log10().
+#
+sub _uplog10 () { 1 / CORE::log(10) }
+
+#
+# i
+#
+# The number defined as i*i = -1;
+#
+sub i () {
+        return $i if ($i);
+	$i = bless {};
+	$i->{'cartesian'} = [0, 1];
+	$i->{'polar'}     = [1, pip2];
+	$i->{c_dirty} = 0;
+	$i->{p_dirty} = 0;
+	return $i;
+}
+
+#
+# _ip2
+#
+# Half of i.
+#
+sub _ip2 () { i / 2 }
+
+#
+# Attribute access/set routines
+#
+
+sub _cartesian {$_[0]->{c_dirty} ?
+		   $_[0]->_update_cartesian : $_[0]->{'cartesian'}}
+sub _polar     {$_[0]->{p_dirty} ?
+		   $_[0]->_update_polar : $_[0]->{'polar'}}
+
+sub _set_cartesian { $_[0]->{p_dirty}++; $_[0]->{c_dirty} = 0;
+		     $_[0]->{'cartesian'} = $_[1] }
+sub _set_polar     { $_[0]->{c_dirty}++; $_[0]->{p_dirty} = 0;
+		     $_[0]->{'polar'} = $_[1] }
+
+#
+# ->_update_cartesian
+#
+# Recompute and return the cartesian form, given accurate polar form.
+#
+sub _update_cartesian {
+	my $self = shift;
+	my ($r, $t) = @{$self->{'polar'}};
+	$self->{c_dirty} = 0;
+	return $self->{'cartesian'} = [$r * CORE::cos($t), $r * CORE::sin($t)];
+}
+
+#
+#
+# ->_update_polar
+#
+# Recompute and return the polar form, given accurate cartesian form.
+#
+sub _update_polar {
+	my $self = shift;
+	my ($x, $y) = @{$self->{'cartesian'}};
+	$self->{p_dirty} = 0;
+	return $self->{'polar'} = [0, 0] if $x == 0 && $y == 0;
+	return $self->{'polar'} = [CORE::sqrt($x*$x + $y*$y),
+				   CORE::atan2($y, $x)];
+}
+
+#
+# (_plus)
+#
+# Computes z1+z2.
+#
+sub _plus {
+	my ($z1, $z2, $regular) = @_;
+	my ($re1, $im1) = @{$z1->_cartesian};
+	$z2 = cplx($z2) unless ref $z2;
+	my ($re2, $im2) = ref $z2 ? @{$z2->_cartesian} : ($z2, 0);
+	unless (defined $regular) {
+		$z1->_set_cartesian([$re1 + $re2, $im1 + $im2]);
+		return $z1;
+	}
+	return (ref $z1)->make($re1 + $re2, $im1 + $im2);
+}
+
+#
+# (_minus)
+#
+# Computes z1-z2.
+#
+sub _minus {
+	my ($z1, $z2, $inverted) = @_;
+	my ($re1, $im1) = @{$z1->_cartesian};
+	$z2 = cplx($z2) unless ref $z2;
+	my ($re2, $im2) = @{$z2->_cartesian};
+	unless (defined $inverted) {
+		$z1->_set_cartesian([$re1 - $re2, $im1 - $im2]);
+		return $z1;
+	}
+	return $inverted ?
+		(ref $z1)->make($re2 - $re1, $im2 - $im1) :
+		(ref $z1)->make($re1 - $re2, $im1 - $im2);
+
+}
+
+#
+# (_multiply)
+#
+# Computes z1*z2.
+#
+sub _multiply {
+        my ($z1, $z2, $regular) = @_;
+	if ($z1->{p_dirty} == 0 and ref $z2 and $z2->{p_dirty} == 0) {
+	    # if both polar better use polar to avoid rounding errors
+	    my ($r1, $t1) = @{$z1->_polar};
+	    my ($r2, $t2) = @{$z2->_polar};
+	    my $t = $t1 + $t2;
+	    if    ($t >   pi()) { $t -= pi2 }
+	    elsif ($t <= -pi()) { $t += pi2 }
+	    unless (defined $regular) {
+		$z1->_set_polar([$r1 * $r2, $t]);
+		return $z1;
+	    }
+	    return (ref $z1)->emake($r1 * $r2, $t);
+	} else {
+	    my ($x1, $y1) = @{$z1->_cartesian};
+	    if (ref $z2) {
+		my ($x2, $y2) = @{$z2->_cartesian};
+		return (ref $z1)->make($x1*$x2-$y1*$y2, $x1*$y2+$y1*$x2);
+	    } else {
+		return (ref $z1)->make($x1*$z2, $y1*$z2);
+	    }
+	}
+}
+
+#
+# _divbyzero
+#
+# Die on division by zero.
+#
+sub _divbyzero {
+    my $mess = "$_[0]: Division by zero.\n";
+
+    if (defined $_[1]) {
+	$mess .= "(Because in the definition of $_[0], the divisor ";
+	$mess .= "$_[1] " unless ("$_[1]" eq '0');
+	$mess .= "is 0)\n";
+    }
+
+    my @up = caller(1);
+
+    $mess .= "Died at $up[1] line $up[2].\n";
+
+    die $mess;
+}
+
+#
+# (_divide)
+#
+# Computes z1/z2.
+#
+sub _divide {
+	my ($z1, $z2, $inverted) = @_;
+	if ($z1->{p_dirty} == 0 and ref $z2 and $z2->{p_dirty} == 0) {
+	    # if both polar better use polar to avoid rounding errors
+	    my ($r1, $t1) = @{$z1->_polar};
+	    my ($r2, $t2) = @{$z2->_polar};
+	    my $t;
+	    if ($inverted) {
+		_divbyzero "$z2/0" if ($r1 == 0);
+		$t = $t2 - $t1;
+		if    ($t >   pi()) { $t -= pi2 }
+		elsif ($t <= -pi()) { $t += pi2 }
+		return (ref $z1)->emake($r2 / $r1, $t);
+	    } else {
+		_divbyzero "$z1/0" if ($r2 == 0);
+		$t = $t1 - $t2;
+		if    ($t >   pi()) { $t -= pi2 }
+		elsif ($t <= -pi()) { $t += pi2 }
+		return (ref $z1)->emake($r1 / $r2, $t);
+	    }
+	} else {
+	    my ($d, $x2, $y2);
+	    if ($inverted) {
+		($x2, $y2) = @{$z1->_cartesian};
+		$d = $x2*$x2 + $y2*$y2;
+		_divbyzero "$z2/0" if $d == 0;
+		return (ref $z1)->make(($x2*$z2)/$d, -($y2*$z2)/$d);
+	    } else {
+		my ($x1, $y1) = @{$z1->_cartesian};
+		if (ref $z2) {
+		    ($x2, $y2) = @{$z2->_cartesian};
+		    $d = $x2*$x2 + $y2*$y2;
+		    _divbyzero "$z1/0" if $d == 0;
+		    my $u = ($x1*$x2 + $y1*$y2)/$d;
+		    my $v = ($y1*$x2 - $x1*$y2)/$d;
+		    return (ref $z1)->make($u, $v);
+		} else {
+		    _divbyzero "$z1/0" if $z2 == 0;
+		    return (ref $z1)->make($x1/$z2, $y1/$z2);
+		}
+	    }
+	}
+}
+
+#
+# (_power)
+#
+# Computes z1**z2 = exp(z2 * log z1)).
+#
+sub _power {
+	my ($z1, $z2, $inverted) = @_;
+	if ($inverted) {
+	    return 1 if $z1 == 0 || $z2 == 1;
+	    return 0 if $z2 == 0 && Re($z1) > 0;
+	} else {
+	    return 1 if $z2 == 0 || $z1 == 1;
+	    return 0 if $z1 == 0 && Re($z2) > 0;
+	}
+	my $w = $inverted ? &exp($z1 * &log($z2))
+	                  : &exp($z2 * &log($z1));
+	# If both arguments cartesian, return cartesian, else polar.
+	return $z1->{c_dirty} == 0 &&
+	       (not ref $z2 or $z2->{c_dirty} == 0) ?
+	       cplx(@{$w->_cartesian}) : $w;
+}
+
+#
+# (_spaceship)
+#
+# Computes z1 <=> z2.
+# Sorts on the real part first, then on the imaginary part. Thus 2-4i < 3+8i.
+#
+sub _spaceship {
+	my ($z1, $z2, $inverted) = @_;
+	my ($re1, $im1) = ref $z1 ? @{$z1->_cartesian} : ($z1, 0);
+	my ($re2, $im2) = ref $z2 ? @{$z2->_cartesian} : ($z2, 0);
+	my $sgn = $inverted ? -1 : 1;
+	return $sgn * ($re1 <=> $re2) if $re1 != $re2;
+	return $sgn * ($im1 <=> $im2);
+}
+
+#
+# (_numeq)
+#
+# Computes z1 == z2.
+#
+# (Required in addition to _spaceship() because of NaNs.)
+sub _numeq {
+	my ($z1, $z2, $inverted) = @_;
+	my ($re1, $im1) = ref $z1 ? @{$z1->_cartesian} : ($z1, 0);
+	my ($re2, $im2) = ref $z2 ? @{$z2->_cartesian} : ($z2, 0);
+	return $re1 == $re2 && $im1 == $im2 ? 1 : 0;
+}
+
+#
+# (_negate)
+#
+# Computes -z.
+#
+sub _negate {
+	my ($z) = @_;
+	if ($z->{c_dirty}) {
+		my ($r, $t) = @{$z->_polar};
+		$t = ($t <= 0) ? $t + pi : $t - pi;
+		return (ref $z)->emake($r, $t);
+	}
+	my ($re, $im) = @{$z->_cartesian};
+	return (ref $z)->make(-$re, -$im);
+}
+
+#
+# (_conjugate)
+#
+# Compute complex's _conjugate.
+#
+sub _conjugate {
+	my ($z) = @_;
+	if ($z->{c_dirty}) {
+		my ($r, $t) = @{$z->_polar};
+		return (ref $z)->emake($r, -$t);
+	}
+	my ($re, $im) = @{$z->_cartesian};
+	return (ref $z)->make($re, -$im);
+}
+
+#
+# (abs)
+#
+# Compute or set complex's norm (rho).
+#
+sub abs {
+	my ($z, $rho) = @_ ? @_ : $_;
+	unless (ref $z) {
+	    if (@_ == 2) {
+		$_[0] = $_[1];
+	    } else {
+		return CORE::abs($z);
+	    }
+	}
+	if (defined $rho) {
+	    $z->{'polar'} = [ $rho, ${$z->_polar}[1] ];
+	    $z->{p_dirty} = 0;
+	    $z->{c_dirty} = 1;
+	    return $rho;
+	} else {
+	    return ${$z->_polar}[0];
+	}
+}
+
+sub _theta {
+    my $theta = $_[0];
+
+    if    ($$theta >   pi()) { $$theta -= pi2 }
+    elsif ($$theta <= -pi()) { $$theta += pi2 }
+}
+
+#
+# arg
+#
+# Compute or set complex's argument (theta).
+#
+sub arg {
+	my ($z, $theta) = @_;
+	return $z unless ref $z;
+	if (defined $theta) {
+	    _theta(\$theta);
+	    $z->{'polar'} = [ ${$z->_polar}[0], $theta ];
+	    $z->{p_dirty} = 0;
+	    $z->{c_dirty} = 1;
+	} else {
+	    $theta = ${$z->_polar}[1];
+	    _theta(\$theta);
+	}
+	return $theta;
+}
+
+#
+# (sqrt)
+#
+# Compute sqrt(z).
+#
+# It is quite tempting to use wantarray here so that in list context
+# sqrt() would return the two solutions.  This, however, would
+# break things like
+#
+#	print "sqrt(z) = ", sqrt($z), "\n";
+#
+# The two values would be printed side by side without no intervening
+# whitespace, quite confusing.
+# Therefore if you want the two solutions use the root().
+#
+sub sqrt {
+	my ($z) = @_ ? $_[0] : $_;
+	my ($re, $im) = ref $z ? @{$z->_cartesian} : ($z, 0);
+	return $re < 0 ? cplx(0, CORE::sqrt(-$re)) : CORE::sqrt($re)
+	    if $im == 0;
+	my ($r, $t) = @{$z->_polar};
+	return (ref $z)->emake(CORE::sqrt($r), $t/2);
+}
+
+#
+# cbrt
+#
+# Compute cbrt(z) (cubic root).
+#
+# Why are we not returning three values?  The same answer as for sqrt().
+#
+sub cbrt {
+	my ($z) = @_;
+	return $z < 0 ?
+	    -CORE::exp(CORE::log(-$z)/3) :
+		($z > 0 ? CORE::exp(CORE::log($z)/3): 0)
+	    unless ref $z;
+	my ($r, $t) = @{$z->_polar};
+	return 0 if $r == 0;
+	return (ref $z)->emake(CORE::exp(CORE::log($r)/3), $t/3);
+}
+
+#
+# _rootbad
+#
+# Die on bad root.
+#
+sub _rootbad {
+    my $mess = "Root '$_[0]' illegal, root rank must be positive integer.\n";
+
+    my @up = caller(1);
+
+    $mess .= "Died at $up[1] line $up[2].\n";
+
+    die $mess;
+}
+
+#
+# root
+#
+# Computes all nth root for z, returning an array whose size is n.
+# `n' must be a positive integer.
+#
+# The roots are given by (for k = 0..n-1):
+#
+# z^(1/n) = r^(1/n) (cos ((t+2 k pi)/n) + i sin ((t+2 k pi)/n))
+#
+sub root {
+	my ($z, $n, $k) = @_;
+	_rootbad($n) if ($n < 1 or int($n) != $n);
+	my ($r, $t) = ref $z ?
+	    @{$z->_polar} : (CORE::abs($z), $z >= 0 ? 0 : pi);
+	my $theta_inc = pi2 / $n;
+	my $rho = $r ** (1/$n);
+	my $cartesian = ref $z && $z->{c_dirty} == 0;
+	if (@_ == 2) {
+	    my @root;
+	    for (my $i = 0, my $theta = $t / $n;
+		 $i < $n;
+		 $i++, $theta += $theta_inc) {
+		my $w = cplxe($rho, $theta);
+		# Yes, $cartesian is loop invariant.
+		push @root, $cartesian ? cplx(@{$w->_cartesian}) : $w;
+	    }
+	    return @root;
+	} elsif (@_ == 3) {
+	    my $w = cplxe($rho, $t / $n + $k * $theta_inc);
+	    return $cartesian ? cplx(@{$w->_cartesian}) : $w;
+	}
+}
+
+#
+# Re
+#
+# Return or set Re(z).
+#
+sub Re {
+	my ($z, $Re) = @_;
+	return $z unless ref $z;
+	if (defined $Re) {
+	    $z->{'cartesian'} = [ $Re, ${$z->_cartesian}[1] ];
+	    $z->{c_dirty} = 0;
+	    $z->{p_dirty} = 1;
+	} else {
+	    return ${$z->_cartesian}[0];
+	}
+}
+
+#
+# Im
+#
+# Return or set Im(z).
+#
+sub Im {
+	my ($z, $Im) = @_;
+	return 0 unless ref $z;
+	if (defined $Im) {
+	    $z->{'cartesian'} = [ ${$z->_cartesian}[0], $Im ];
+	    $z->{c_dirty} = 0;
+	    $z->{p_dirty} = 1;
+	} else {
+	    return ${$z->_cartesian}[1];
+	}
+}
+
+#
+# rho
+#
+# Return or set rho(w).
+#
+sub rho {
+    Math::Complex::abs(@_);
+}
+
+#
+# theta
+#
+# Return or set theta(w).
+#
+sub theta {
+    Math::Complex::arg(@_);
+}
+
+#
+# (exp)
+#
+# Computes exp(z).
+#
+sub exp {
+    my ($z) = @_ ? @_ : $_;
+    return CORE::exp($z) unless ref $z;
+    my ($x, $y) = @{$z->_cartesian};
+    return (ref $z)->emake(CORE::exp($x), $y);
+}
+
+#
+# _logofzero
+#
+# Die on logarithm of zero.
+#
+sub _logofzero {
+    my $mess = "$_[0]: Logarithm of zero.\n";
+
+    if (defined $_[1]) {
+	$mess .= "(Because in the definition of $_[0], the argument ";
+	$mess .= "$_[1] " unless ($_[1] eq '0');
+	$mess .= "is 0)\n";
+    }
+
+    my @up = caller(1);
+
+    $mess .= "Died at $up[1] line $up[2].\n";
+
+    die $mess;
+}
+
+#
+# (log)
+#
+# Compute log(z).
+#
+sub log {
+	my ($z) = @_ ? @_ : $_;
+	unless (ref $z) {
+	    _logofzero("log") if $z == 0;
+	    return $z > 0 ? CORE::log($z) : cplx(CORE::log(-$z), pi);
+	}
+	my ($r, $t) = @{$z->_polar};
+	_logofzero("log") if $r == 0;
+	if    ($t >   pi()) { $t -= pi2 }
+	elsif ($t <= -pi()) { $t += pi2 }
+	return (ref $z)->make(CORE::log($r), $t);
+}
+
+#
+# ln
+#
+# Alias for log().
+#
+sub ln { Math::Complex::log(@_) }
+
+#
+# log10
+#
+# Compute log10(z).
+#
+
+sub log10 {
+	return Math::Complex::log($_[0]) * _uplog10;
+}
+
+#
+# logn
+#
+# Compute logn(z,n) = log(z) / log(n)
+#
+sub logn {
+	my ($z, $n) = @_;
+	$z = cplx($z, 0) unless ref $z;
+	my $logn = $LOGN{$n};
+	$logn = $LOGN{$n} = CORE::log($n) unless defined $logn;	# Cache log(n)
+	return &log($z) / $logn;
+}
+
+#
+# (cos)
+#
+# Compute cos(z) = (exp(iz) + exp(-iz))/2.
+#
+sub cos {
+	my ($z) = @_ ? @_ : $_;
+	return CORE::cos($z) unless ref $z;
+	my ($x, $y) = @{$z->_cartesian};
+	my $ey = CORE::exp($y);
+	my $sx = CORE::sin($x);
+	my $cx = CORE::cos($x);
+	my $ey_1 = $ey ? 1 / $ey : Inf();
+	return (ref $z)->make($cx * ($ey + $ey_1)/2,
+			      $sx * ($ey_1 - $ey)/2);
+}
+
+#
+# (sin)
+#
+# Compute sin(z) = (exp(iz) - exp(-iz))/2.
+#
+sub sin {
+	my ($z) = @_ ? @_ : $_;
+	return CORE::sin($z) unless ref $z;
+	my ($x, $y) = @{$z->_cartesian};
+	my $ey = CORE::exp($y);
+	my $sx = CORE::sin($x);
+	my $cx = CORE::cos($x);
+	my $ey_1 = $ey ? 1 / $ey : Inf();
+	return (ref $z)->make($sx * ($ey + $ey_1)/2,
+			      $cx * ($ey - $ey_1)/2);
+}
+
+#
+# tan
+#
+# Compute tan(z) = sin(z) / cos(z).
+#
+sub tan {
+	my ($z) = @_;
+	my $cz = &cos($z);
+	_divbyzero "tan($z)", "cos($z)" if $cz == 0;
+	return &sin($z) / $cz;
+}
+
+#
+# sec
+#
+# Computes the secant sec(z) = 1 / cos(z).
+#
+sub sec {
+	my ($z) = @_;
+	my $cz = &cos($z);
+	_divbyzero "sec($z)", "cos($z)" if ($cz == 0);
+	return 1 / $cz;
+}
+
+#
+# csc
+#
+# Computes the cosecant csc(z) = 1 / sin(z).
+#
+sub csc {
+	my ($z) = @_;
+	my $sz = &sin($z);
+	_divbyzero "csc($z)", "sin($z)" if ($sz == 0);
+	return 1 / $sz;
+}
+
+#
+# cosec
+#
+# Alias for csc().
+#
+sub cosec { Math::Complex::csc(@_) }
+
+#
+# cot
+#
+# Computes cot(z) = cos(z) / sin(z).
+#
+sub cot {
+	my ($z) = @_;
+	my $sz = &sin($z);
+	_divbyzero "cot($z)", "sin($z)" if ($sz == 0);
+	return &cos($z) / $sz;
+}
+
+#
+# cotan
+#
+# Alias for cot().
+#
+sub cotan { Math::Complex::cot(@_) }
+
+#
+# acos
+#
+# Computes the arc cosine acos(z) = -i log(z + sqrt(z*z-1)).
+#
+sub acos {
+	my $z = $_[0];
+	return CORE::atan2(CORE::sqrt(1-$z*$z), $z)
+	    if (! ref $z) && CORE::abs($z) <= 1;
+	$z = cplx($z, 0) unless ref $z;
+	my ($x, $y) = @{$z->_cartesian};
+	return 0 if $x == 1 && $y == 0;
+	my $t1 = CORE::sqrt(($x+1)*($x+1) + $y*$y);
+	my $t2 = CORE::sqrt(($x-1)*($x-1) + $y*$y);
+	my $alpha = ($t1 + $t2)/2;
+	my $beta  = ($t1 - $t2)/2;
+	$alpha = 1 if $alpha < 1;
+	if    ($beta >  1) { $beta =  1 }
+	elsif ($beta < -1) { $beta = -1 }
+	my $u = CORE::atan2(CORE::sqrt(1-$beta*$beta), $beta);
+	my $v = CORE::log($alpha + CORE::sqrt($alpha*$alpha-1));
+	$v = -$v if $y > 0 || ($y == 0 && $x < -1);
+	return (ref $z)->make($u, $v);
+}
+
+#
+# asin
+#
+# Computes the arc sine asin(z) = -i log(iz + sqrt(1-z*z)).
+#
+sub asin {
+	my $z = $_[0];
+	return CORE::atan2($z, CORE::sqrt(1-$z*$z))
+	    if (! ref $z) && CORE::abs($z) <= 1;
+	$z = cplx($z, 0) unless ref $z;
+	my ($x, $y) = @{$z->_cartesian};
+	return 0 if $x == 0 && $y == 0;
+	my $t1 = CORE::sqrt(($x+1)*($x+1) + $y*$y);
+	my $t2 = CORE::sqrt(($x-1)*($x-1) + $y*$y);
+	my $alpha = ($t1 + $t2)/2;
+	my $beta  = ($t1 - $t2)/2;
+	$alpha = 1 if $alpha < 1;
+	if    ($beta >  1) { $beta =  1 }
+	elsif ($beta < -1) { $beta = -1 }
+	my $u =  CORE::atan2($beta, CORE::sqrt(1-$beta*$beta));
+	my $v = -CORE::log($alpha + CORE::sqrt($alpha*$alpha-1));
+	$v = -$v if $y > 0 || ($y == 0 && $x < -1);
+	return (ref $z)->make($u, $v);
+}
+
+#
+# atan
+#
+# Computes the arc tangent atan(z) = i/2 log((i+z) / (i-z)).
+#
+sub atan {
+	my ($z) = @_;
+	return CORE::atan2($z, 1) unless ref $z;
+	my ($x, $y) = ref $z ? @{$z->_cartesian} : ($z, 0);
+	return 0 if $x == 0 && $y == 0;
+	_divbyzero "atan(i)"  if ( $z == i);
+	_logofzero "atan(-i)" if (-$z == i); # -i is a bad file test...
+	my $log = &log((i + $z) / (i - $z));
+	return _ip2 * $log;
+}
+
+#
+# asec
+#
+# Computes the arc secant asec(z) = acos(1 / z).
+#
+sub asec {
+	my ($z) = @_;
+	_divbyzero "asec($z)", $z if ($z == 0);
+	return acos(1 / $z);
+}
+
+#
+# acsc
+#
+# Computes the arc cosecant acsc(z) = asin(1 / z).
+#
+sub acsc {
+	my ($z) = @_;
+	_divbyzero "acsc($z)", $z if ($z == 0);
+	return asin(1 / $z);
+}
+
+#
+# acosec
+#
+# Alias for acsc().
+#
+sub acosec { Math::Complex::acsc(@_) }
+
+#
+# acot
+#
+# Computes the arc cotangent acot(z) = atan(1 / z)
+#
+sub acot {
+	my ($z) = @_;
+	_divbyzero "acot(0)"  if $z == 0;
+	return ($z >= 0) ? CORE::atan2(1, $z) : CORE::atan2(-1, -$z)
+	    unless ref $z;
+	_divbyzero "acot(i)"  if ($z - i == 0);
+	_logofzero "acot(-i)" if ($z + i == 0);
+	return atan(1 / $z);
+}
+
+#
+# acotan
+#
+# Alias for acot().
+#
+sub acotan { Math::Complex::acot(@_) }
+
+#
+# cosh
+#
+# Computes the hyperbolic cosine cosh(z) = (exp(z) + exp(-z))/2.
+#
+sub cosh {
+	my ($z) = @_;
+	my $ex;
+	unless (ref $z) {
+	    $ex = CORE::exp($z);
+            return $ex ? ($ex == $ExpInf ? Inf() : ($ex + 1/$ex)/2) : Inf();
+	}
+	my ($x, $y) = @{$z->_cartesian};
+	$ex = CORE::exp($x);
+	my $ex_1 = $ex ? 1 / $ex : Inf();
+	return (ref $z)->make(CORE::cos($y) * ($ex + $ex_1)/2,
+			      CORE::sin($y) * ($ex - $ex_1)/2);
+}
+
+#
+# sinh
+#
+# Computes the hyperbolic sine sinh(z) = (exp(z) - exp(-z))/2.
+#
+sub sinh {
+	my ($z) = @_;
+	my $ex;
+	unless (ref $z) {
+	    return 0 if $z == 0;
+	    $ex = CORE::exp($z);
+            return $ex ? ($ex == $ExpInf ? Inf() : ($ex - 1/$ex)/2) : -Inf();
+	}
+	my ($x, $y) = @{$z->_cartesian};
+	my $cy = CORE::cos($y);
+	my $sy = CORE::sin($y);
+	$ex = CORE::exp($x);
+	my $ex_1 = $ex ? 1 / $ex : Inf();
+	return (ref $z)->make(CORE::cos($y) * ($ex - $ex_1)/2,
+			      CORE::sin($y) * ($ex + $ex_1)/2);
+}
+
+#
+# tanh
+#
+# Computes the hyperbolic tangent tanh(z) = sinh(z) / cosh(z).
+#
+sub tanh {
+	my ($z) = @_;
+	my $cz = cosh($z);
+	_divbyzero "tanh($z)", "cosh($z)" if ($cz == 0);
+	my $sz = sinh($z);
+	return  1 if $cz ==  $sz;
+	return -1 if $cz == -$sz;
+	return $sz / $cz;
+}
+
+#
+# sech
+#
+# Computes the hyperbolic secant sech(z) = 1 / cosh(z).
+#
+sub sech {
+	my ($z) = @_;
+	my $cz = cosh($z);
+	_divbyzero "sech($z)", "cosh($z)" if ($cz == 0);
+	return 1 / $cz;
+}
+
+#
+# csch
+#
+# Computes the hyperbolic cosecant csch(z) = 1 / sinh(z).
+#
+sub csch {
+	my ($z) = @_;
+	my $sz = sinh($z);
+	_divbyzero "csch($z)", "sinh($z)" if ($sz == 0);
+	return 1 / $sz;
+}
+
+#
+# cosech
+#
+# Alias for csch().
+#
+sub cosech { Math::Complex::csch(@_) }
+
+#
+# coth
+#
+# Computes the hyperbolic cotangent coth(z) = cosh(z) / sinh(z).
+#
+sub coth {
+	my ($z) = @_;
+	my $sz = sinh($z);
+	_divbyzero "coth($z)", "sinh($z)" if $sz == 0;
+	my $cz = cosh($z);
+	return  1 if $cz ==  $sz;
+	return -1 if $cz == -$sz;
+	return $cz / $sz;
+}
+
+#
+# cotanh
+#
+# Alias for coth().
+#
+sub cotanh { Math::Complex::coth(@_) }
+
+#
+# acosh
+#
+# Computes the area/inverse hyperbolic cosine acosh(z) = log(z + sqrt(z*z-1)).
+#
+sub acosh {
+	my ($z) = @_;
+	unless (ref $z) {
+	    $z = cplx($z, 0);
+	}
+	my ($re, $im) = @{$z->_cartesian};
+	if ($im == 0) {
+	    return CORE::log($re + CORE::sqrt($re*$re - 1))
+		if $re >= 1;
+	    return cplx(0, CORE::atan2(CORE::sqrt(1 - $re*$re), $re))
+		if CORE::abs($re) < 1;
+	}
+	my $t = &sqrt($z * $z - 1) + $z;
+	# Try Taylor if looking bad (this usually means that
+	# $z was large negative, therefore the sqrt is really
+	# close to abs(z), summing that with z...)
+	$t = 1/(2 * $z) - 1/(8 * $z**3) + 1/(16 * $z**5) - 5/(128 * $z**7)
+	    if $t == 0;
+	my $u = &log($t);
+	$u->Im(-$u->Im) if $re < 0 && $im == 0;
+	return $re < 0 ? -$u : $u;
+}
+
+#
+# asinh
+#
+# Computes the area/inverse hyperbolic sine asinh(z) = log(z + sqrt(z*z+1))
+#
+sub asinh {
+	my ($z) = @_;
+	unless (ref $z) {
+	    my $t = $z + CORE::sqrt($z*$z + 1);
+	    return CORE::log($t) if $t;
+	}
+	my $t = &sqrt($z * $z + 1) + $z;
+	# Try Taylor if looking bad (this usually means that
+	# $z was large negative, therefore the sqrt is really
+	# close to abs(z), summing that with z...)
+	$t = 1/(2 * $z) - 1/(8 * $z**3) + 1/(16 * $z**5) - 5/(128 * $z**7)
+	    if $t == 0;
+	return &log($t);
+}
+
+#
+# atanh
+#
+# Computes the area/inverse hyperbolic tangent atanh(z) = 1/2 log((1+z) / (1-z)).
+#
+sub atanh {
+	my ($z) = @_;
+	unless (ref $z) {
+	    return CORE::log((1 + $z)/(1 - $z))/2 if CORE::abs($z) < 1;
+	    $z = cplx($z, 0);
+	}
+	_divbyzero 'atanh(1)',  "1 - $z" if (1 - $z == 0);
+	_logofzero 'atanh(-1)'           if (1 + $z == 0);
+	return 0.5 * &log((1 + $z) / (1 - $z));
+}
+
+#
+# asech
+#
+# Computes the area/inverse hyperbolic secant asech(z) = acosh(1 / z).
+#
+sub asech {
+	my ($z) = @_;
+	_divbyzero 'asech(0)', "$z" if ($z == 0);
+	return acosh(1 / $z);
+}
+
+#
+# acsch
+#
+# Computes the area/inverse hyperbolic cosecant acsch(z) = asinh(1 / z).
+#
+sub acsch {
+	my ($z) = @_;
+	_divbyzero 'acsch(0)', $z if ($z == 0);
+	return asinh(1 / $z);
+}
+
+#
+# acosech
+#
+# Alias for acosh().
+#
+sub acosech { Math::Complex::acsch(@_) }
+
+#
+# acoth
+#
+# Computes the area/inverse hyperbolic cotangent acoth(z) = 1/2 log((1+z) / (z-1)).
+#
+sub acoth {
+	my ($z) = @_;
+	_divbyzero 'acoth(0)'            if ($z == 0);
+	unless (ref $z) {
+	    return CORE::log(($z + 1)/($z - 1))/2 if CORE::abs($z) > 1;
+	    $z = cplx($z, 0);
+	}
+	_divbyzero 'acoth(1)',  "$z - 1" if ($z - 1 == 0);
+	_logofzero 'acoth(-1)', "1 + $z" if (1 + $z == 0);
+	return &log((1 + $z) / ($z - 1)) / 2;
+}
+
+#
+# acotanh
+#
+# Alias for acot().
+#
+sub acotanh { Math::Complex::acoth(@_) }
+
+#
+# (atan2)
+#
+# Compute atan(z1/z2), minding the right quadrant.
+#
+sub atan2 {
+	my ($z1, $z2, $inverted) = @_;
+	my ($re1, $im1, $re2, $im2);
+	if ($inverted) {
+	    ($re1, $im1) = ref $z2 ? @{$z2->_cartesian} : ($z2, 0);
+	    ($re2, $im2) = ref $z1 ? @{$z1->_cartesian} : ($z1, 0);
+	} else {
+	    ($re1, $im1) = ref $z1 ? @{$z1->_cartesian} : ($z1, 0);
+	    ($re2, $im2) = ref $z2 ? @{$z2->_cartesian} : ($z2, 0);
+	}
+	if ($im1 || $im2) {
+	    # In MATLAB the imaginary parts are ignored.
+	    # warn "atan2: Imaginary parts ignored";
+	    # http://documents.wolfram.com/mathematica/functions/ArcTan
+	    # NOTE: Mathematica ArcTan[x,y] while atan2(y,x)
+	    my $s = $z1 * $z1 + $z2 * $z2;
+	    _divbyzero("atan2") if $s == 0;
+	    my $i = &i;
+	    my $r = $z2 + $z1 * $i;
+	    return -$i * &log($r / &sqrt( $s ));
+	}
+	return CORE::atan2($re1, $re2);
+}
+
+#
+# display_format
+# ->display_format
+#
+# Set (get if no argument) the display format for all complex numbers that
+# don't happen to have overridden it via ->display_format
+#
+# When called as an object method, this actually sets the display format for
+# the current object.
+#
+# Valid object formats are 'c' and 'p' for cartesian and polar. The first
+# letter is used actually, so the type can be fully spelled out for clarity.
+#
+sub display_format {
+	my $self  = shift;
+	my %display_format = %DISPLAY_FORMAT;
+
+	if (ref $self) {			# Called as an object method
+	    if (exists $self->{display_format}) {
+		my %obj = %{$self->{display_format}};
+		@display_format{keys %obj} = values %obj;
+	    }
+	}
+	if (@_ == 1) {
+	    $display_format{style} = shift;
+	} else {
+	    my %new = @_;
+	    @display_format{keys %new} = values %new;
+	}
+
+	if (ref $self) { # Called as an object method
+	    $self->{display_format} = { %display_format };
+	    return
+		wantarray ?
+		    %{$self->{display_format}} :
+		    $self->{display_format}->{style};
+	}
+
+        # Called as a class method
+	%DISPLAY_FORMAT = %display_format;
+	return
+	    wantarray ?
+		%DISPLAY_FORMAT :
+		    $DISPLAY_FORMAT{style};
+}
+
+#
+# (_stringify)
+#
+# Show nicely formatted complex number under its cartesian or polar form,
+# depending on the current display format:
+#
+# . If a specific display format has been recorded for this object, use it.
+# . Otherwise, use the generic current default for all complex numbers,
+#   which is a package global variable.
+#
+sub _stringify {
+	my ($z) = shift;
+
+	my $style = $z->display_format;
+
+	$style = $DISPLAY_FORMAT{style} unless defined $style;
+
+	return $z->_stringify_polar if $style =~ /^p/i;
+	return $z->_stringify_cartesian;
+}
+
+#
+# ->_stringify_cartesian
+#
+# Stringify as a cartesian representation 'a+bi'.
+#
+sub _stringify_cartesian {
+	my $z  = shift;
+	my ($x, $y) = @{$z->_cartesian};
+	my ($re, $im);
+
+	my %format = $z->display_format;
+	my $format = $format{format};
+
+	if ($x) {
+	    if ($x =~ /^NaN[QS]?$/i) {
+		$re = $x;
+	    } else {
+		if ($x =~ /^-?\Q$Inf\E$/oi) {
+		    $re = $x;
+		} else {
+		    $re = defined $format ? sprintf($format, $x) : $x;
+		}
+	    }
+	} else {
+	    undef $re;
+	}
+
+	if ($y) {
+	    if ($y =~ /^(NaN[QS]?)$/i) {
+		$im = $y;
+	    } else {
+		if ($y =~ /^-?\Q$Inf\E$/oi) {
+		    $im = $y;
+		} else {
+		    $im =
+			defined $format ?
+			    sprintf($format, $y) :
+			    ($y == 1 ? "" : ($y == -1 ? "-" : $y));
+		}
+	    }
+	    $im .= "i";
+	} else {
+	    undef $im;
+	}
+
+	my $str = $re;
+
+	if (defined $im) {
+	    if ($y < 0) {
+		$str .= $im;
+	    } elsif ($y > 0 || $im =~ /^NaN[QS]?i$/i)  {
+		$str .= "+" if defined $re;
+		$str .= $im;
+	    }
+	} elsif (!defined $re) {
+	    $str = "0";
+	}
+
+	return $str;
+}
+
+
+#
+# ->_stringify_polar
+#
+# Stringify as a polar representation '[r,t]'.
+#
+sub _stringify_polar {
+	my $z  = shift;
+	my ($r, $t) = @{$z->_polar};
+	my $theta;
+
+	my %format = $z->display_format;
+	my $format = $format{format};
+
+	if ($t =~ /^NaN[QS]?$/i || $t =~ /^-?\Q$Inf\E$/oi) {
+	    $theta = $t; 
+	} elsif ($t == pi) {
+	    $theta = "pi";
+	} elsif ($r == 0 || $t == 0) {
+	    $theta = defined $format ? sprintf($format, $t) : $t;
+	}
+
+	return "[$r,$theta]" if defined $theta;
+
+	#
+	# Try to identify pi/n and friends.
+	#
+
+	$t -= int(CORE::abs($t) / pi2) * pi2;
+
+	if ($format{polar_pretty_print} && $t) {
+	    my ($a, $b);
+	    for $a (2..9) {
+		$b = $t * $a / pi;
+		if ($b =~ /^-?\d+$/) {
+		    $b = $b < 0 ? "-" : "" if CORE::abs($b) == 1;
+		    $theta = "${b}pi/$a";
+		    last;
+		}
+	    }
+	}
+
+        if (defined $format) {
+	    $r     = sprintf($format, $r);
+	    $theta = sprintf($format, $t) unless defined $theta;
+	} else {
+	    $theta = $t unless defined $theta;
+	}
+
+	return "[$r,$theta]";
+}
+
+sub Inf {
+    return $Inf;
+}
+
+1;
+__END__
+
+=pod
+
+=head1 NAME
+
+Math::Complex - complex numbers and associated mathematical functions
+
+=head1 SYNOPSIS
+
+	use Math::Complex;
+
+	$z = Math::Complex->make(5, 6);
+	$t = 4 - 3*i + $z;
+	$j = cplxe(1, 2*pi/3);
+
+=head1 DESCRIPTION
+
+This package lets you create and manipulate complex numbers. By default,
+I<Perl> limits itself to real numbers, but an extra C<use> statement brings
+full complex support, along with a full set of mathematical functions
+typically associated with and/or extended to complex numbers.
+
+If you wonder what complex numbers are, they were invented to be able to solve
+the following equation:
+
+	x*x = -1
+
+and by definition, the solution is noted I<i> (engineers use I<j> instead since
+I<i> usually denotes an intensity, but the name does not matter). The number
+I<i> is a pure I<imaginary> number.
+
+The arithmetics with pure imaginary numbers works just like you would expect
+it with real numbers... you just have to remember that
+
+	i*i = -1
+
+so you have:
+
+	5i + 7i = i * (5 + 7) = 12i
+	4i - 3i = i * (4 - 3) = i
+	4i * 2i = -8
+	6i / 2i = 3
+	1 / i = -i
+
+Complex numbers are numbers that have both a real part and an imaginary
+part, and are usually noted:
+
+	a + bi
+
+where C<a> is the I<real> part and C<b> is the I<imaginary> part. The
+arithmetic with complex numbers is straightforward. You have to
+keep track of the real and the imaginary parts, but otherwise the
+rules used for real numbers just apply:
+
+	(4 + 3i) + (5 - 2i) = (4 + 5) + i(3 - 2) = 9 + i
+	(2 + i) * (4 - i) = 2*4 + 4i -2i -i*i = 8 + 2i + 1 = 9 + 2i
+
+A graphical representation of complex numbers is possible in a plane
+(also called the I<complex plane>, but it's really a 2D plane).
+The number
+
+	z = a + bi
+
+is the point whose coordinates are (a, b). Actually, it would
+be the vector originating from (0, 0) to (a, b). It follows that the addition
+of two complex numbers is a vectorial addition.
+
+Since there is a bijection between a point in the 2D plane and a complex
+number (i.e. the mapping is unique and reciprocal), a complex number
+can also be uniquely identified with polar coordinates:
+
+	[rho, theta]
+
+where C<rho> is the distance to the origin, and C<theta> the angle between
+the vector and the I<x> axis. There is a notation for this using the
+exponential form, which is:
+
+	rho * exp(i * theta)
+
+where I<i> is the famous imaginary number introduced above. Conversion
+between this form and the cartesian form C<a + bi> is immediate:
+
+	a = rho * cos(theta)
+	b = rho * sin(theta)
+
+which is also expressed by this formula:
+
+	z = rho * exp(i * theta) = rho * (cos theta + i * sin theta)
+
+In other words, it's the projection of the vector onto the I<x> and I<y>
+axes. Mathematicians call I<rho> the I<norm> or I<modulus> and I<theta>
+the I<argument> of the complex number. The I<norm> of C<z> is
+marked here as C<abs(z)>.
+
+The polar notation (also known as the trigonometric representation) is
+much more handy for performing multiplications and divisions of
+complex numbers, whilst the cartesian notation is better suited for
+additions and subtractions. Real numbers are on the I<x> axis, and
+therefore I<y> or I<theta> is zero or I<pi>.
+
+All the common operations that can be performed on a real number have
+been defined to work on complex numbers as well, and are merely
+I<extensions> of the operations defined on real numbers. This means
+they keep their natural meaning when there is no imaginary part, provided
+the number is within their definition set.
+
+For instance, the C<sqrt> routine which computes the square root of
+its argument is only defined for non-negative real numbers and yields a
+non-negative real number (it is an application from B<R+> to B<R+>).
+If we allow it to return a complex number, then it can be extended to
+negative real numbers to become an application from B<R> to B<C> (the
+set of complex numbers):
+
+	sqrt(x) = x >= 0 ? sqrt(x) : sqrt(-x)*i
+
+It can also be extended to be an application from B<C> to B<C>,
+whilst its restriction to B<R> behaves as defined above by using
+the following definition:
+
+	sqrt(z = [r,t]) = sqrt(r) * exp(i * t/2)
+
+Indeed, a negative real number can be noted C<[x,pi]> (the modulus
+I<x> is always non-negative, so C<[x,pi]> is really C<-x>, a negative
+number) and the above definition states that
+
+	sqrt([x,pi]) = sqrt(x) * exp(i*pi/2) = [sqrt(x),pi/2] = sqrt(x)*i
+
+which is exactly what we had defined for negative real numbers above.
+The C<sqrt> returns only one of the solutions: if you want the both,
+use the C<root> function.
+
+All the common mathematical functions defined on real numbers that
+are extended to complex numbers share that same property of working
+I<as usual> when the imaginary part is zero (otherwise, it would not
+be called an extension, would it?).
+
+A I<new> operation possible on a complex number that is
+the identity for real numbers is called the I<conjugate>, and is noted
+with a horizontal bar above the number, or C<~z> here.
+
+	 z = a + bi
+	~z = a - bi
+
+Simple... Now look:
+
+	z * ~z = (a + bi) * (a - bi) = a*a + b*b
+
+We saw that the norm of C<z> was noted C<abs(z)> and was defined as the
+distance to the origin, also known as:
+
+	rho = abs(z) = sqrt(a*a + b*b)
+
+so
+
+	z * ~z = abs(z) ** 2
+
+If z is a pure real number (i.e. C<b == 0>), then the above yields:
+
+	a * a = abs(a) ** 2
+
+which is true (C<abs> has the regular meaning for real number, i.e. stands
+for the absolute value). This example explains why the norm of C<z> is
+noted C<abs(z)>: it extends the C<abs> function to complex numbers, yet
+is the regular C<abs> we know when the complex number actually has no
+imaginary part... This justifies I<a posteriori> our use of the C<abs>
+notation for the norm.
+
+=head1 OPERATIONS
+
+Given the following notations:
+
+	z1 = a + bi = r1 * exp(i * t1)
+	z2 = c + di = r2 * exp(i * t2)
+	z = <any complex or real number>
+
+the following (overloaded) operations are supported on complex numbers:
+
+	z1 + z2 = (a + c) + i(b + d)
+	z1 - z2 = (a - c) + i(b - d)
+	z1 * z2 = (r1 * r2) * exp(i * (t1 + t2))
+	z1 / z2 = (r1 / r2) * exp(i * (t1 - t2))
+	z1 ** z2 = exp(z2 * log z1)
+	~z = a - bi
+	abs(z) = r1 = sqrt(a*a + b*b)
+	sqrt(z) = sqrt(r1) * exp(i * t/2)
+	exp(z) = exp(a) * exp(i * b)
+	log(z) = log(r1) + i*t
+	sin(z) = 1/2i (exp(i * z1) - exp(-i * z))
+	cos(z) = 1/2 (exp(i * z1) + exp(-i * z))
+	atan2(y, x) = atan(y / x) # Minding the right quadrant, note the order.
+
+The definition used for complex arguments of atan2() is
+
+       -i log((x + iy)/sqrt(x*x+y*y))
+
+Note that atan2(0, 0) is not well-defined.
+
+The following extra operations are supported on both real and complex
+numbers:
+
+	Re(z) = a
+	Im(z) = b
+	arg(z) = t
+	abs(z) = r
+
+	cbrt(z) = z ** (1/3)
+	log10(z) = log(z) / log(10)
+	logn(z, n) = log(z) / log(n)
+
+	tan(z) = sin(z) / cos(z)
+
+	csc(z) = 1 / sin(z)
+	sec(z) = 1 / cos(z)
+	cot(z) = 1 / tan(z)
+
+	asin(z) = -i * log(i*z + sqrt(1-z*z))
+	acos(z) = -i * log(z + i*sqrt(1-z*z))
+	atan(z) = i/2 * log((i+z) / (i-z))
+
+	acsc(z) = asin(1 / z)
+	asec(z) = acos(1 / z)
+	acot(z) = atan(1 / z) = -i/2 * log((i+z) / (z-i))
+
+	sinh(z) = 1/2 (exp(z) - exp(-z))
+	cosh(z) = 1/2 (exp(z) + exp(-z))
+	tanh(z) = sinh(z) / cosh(z) = (exp(z) - exp(-z)) / (exp(z) + exp(-z))
+
+	csch(z) = 1 / sinh(z)
+	sech(z) = 1 / cosh(z)
+	coth(z) = 1 / tanh(z)
+
+	asinh(z) = log(z + sqrt(z*z+1))
+	acosh(z) = log(z + sqrt(z*z-1))
+	atanh(z) = 1/2 * log((1+z) / (1-z))
+
+	acsch(z) = asinh(1 / z)
+	asech(z) = acosh(1 / z)
+	acoth(z) = atanh(1 / z) = 1/2 * log((1+z) / (z-1))
+
+I<arg>, I<abs>, I<log>, I<csc>, I<cot>, I<acsc>, I<acot>, I<csch>,
+I<coth>, I<acosech>, I<acotanh>, have aliases I<rho>, I<theta>, I<ln>,
+I<cosec>, I<cotan>, I<acosec>, I<acotan>, I<cosech>, I<cotanh>,
+I<acosech>, I<acotanh>, respectively.  C<Re>, C<Im>, C<arg>, C<abs>,
+C<rho>, and C<theta> can be used also as mutators.  The C<cbrt>
+returns only one of the solutions: if you want all three, use the
+C<root> function.
+
+The I<root> function is available to compute all the I<n>
+roots of some complex, where I<n> is a strictly positive integer.
+There are exactly I<n> such roots, returned as a list. Getting the
+number mathematicians call C<j> such that:
+
+	1 + j + j*j = 0;
+
+is a simple matter of writing:
+
+	$j = (root(1, 3))[1];
+
+The I<k>th root for C<z = [r,t]> is given by:
+
+	(root(z, n))[k] = r**(1/n) * exp(i * (t + 2*k*pi)/n)
+
+You can return the I<k>th root directly by C<root(z, n, k)>,
+indexing starting from I<zero> and ending at I<n - 1>.
+
+The I<spaceship> numeric comparison operator, E<lt>=E<gt>, is also
+defined. In order to ensure its restriction to real numbers is conform
+to what you would expect, the comparison is run on the real part of
+the complex number first, and imaginary parts are compared only when
+the real parts match.
+
+=head1 CREATION
+
+To create a complex number, use either:
+
+	$z = Math::Complex->make(3, 4);
+	$z = cplx(3, 4);
+
+if you know the cartesian form of the number, or
+
+	$z = 3 + 4*i;
+
+if you like. To create a number using the polar form, use either:
+
+	$z = Math::Complex->emake(5, pi/3);
+	$x = cplxe(5, pi/3);
+
+instead. The first argument is the modulus, the second is the angle
+(in radians, the full circle is 2*pi).  (Mnemonic: C<e> is used as a
+notation for complex numbers in the polar form).
+
+It is possible to write:
+
+	$x = cplxe(-3, pi/4);
+
+but that will be silently converted into C<[3,-3pi/4]>, since the
+modulus must be non-negative (it represents the distance to the origin
+in the complex plane).
+
+It is also possible to have a complex number as either argument of the
+C<make>, C<emake>, C<cplx>, and C<cplxe>: the appropriate component of
+the argument will be used.
+
+	$z1 = cplx(-2,  1);
+	$z2 = cplx($z1, 4);
+
+The C<new>, C<make>, C<emake>, C<cplx>, and C<cplxe> will also
+understand a single (string) argument of the forms
+
+    	2-3i
+    	-3i
+	[2,3]
+	[2,-3pi/4]
+	[2]
+
+in which case the appropriate cartesian and exponential components
+will be parsed from the string and used to create new complex numbers.
+The imaginary component and the theta, respectively, will default to zero.
+
+The C<new>, C<make>, C<emake>, C<cplx>, and C<cplxe> will also
+understand the case of no arguments: this means plain zero or (0, 0).
+
+=head1 DISPLAYING
+
+When printed, a complex number is usually shown under its cartesian
+style I<a+bi>, but there are legitimate cases where the polar style
+I<[r,t]> is more appropriate.  The process of converting the complex
+number into a string that can be displayed is known as I<stringification>.
+
+By calling the class method C<Math::Complex::display_format> and
+supplying either C<"polar"> or C<"cartesian"> as an argument, you
+override the default display style, which is C<"cartesian">. Not
+supplying any argument returns the current settings.
+
+This default can be overridden on a per-number basis by calling the
+C<display_format> method instead. As before, not supplying any argument
+returns the current display style for this number. Otherwise whatever you
+specify will be the new display style for I<this> particular number.
+
+For instance:
+
+	use Math::Complex;
+
+	Math::Complex::display_format('polar');
+	$j = (root(1, 3))[1];
+	print "j = $j\n";		# Prints "j = [1,2pi/3]"
+	$j->display_format('cartesian');
+	print "j = $j\n";		# Prints "j = -0.5+0.866025403784439i"
+
+The polar style attempts to emphasize arguments like I<k*pi/n>
+(where I<n> is a positive integer and I<k> an integer within [-9, +9]),
+this is called I<polar pretty-printing>.
+
+For the reverse of stringifying, see the C<make> and C<emake>.
+
+=head2 CHANGED IN PERL 5.6
+
+The C<display_format> class method and the corresponding
+C<display_format> object method can now be called using
+a parameter hash instead of just a one parameter.
+
+The old display format style, which can have values C<"cartesian"> or
+C<"polar">, can be changed using the C<"style"> parameter.
+
+	$j->display_format(style => "polar");
+
+The one parameter calling convention also still works.
+
+	$j->display_format("polar");
+
+There are two new display parameters.
+
+The first one is C<"format">, which is a sprintf()-style format string
+to be used for both numeric parts of the complex number(s).  The is
+somewhat system-dependent but most often it corresponds to C<"%.15g">.
+You can revert to the default by setting the C<format> to C<undef>.
+
+	# the $j from the above example
+
+	$j->display_format('format' => '%.5f');
+	print "j = $j\n";		# Prints "j = -0.50000+0.86603i"
+	$j->display_format('format' => undef);
+	print "j = $j\n";		# Prints "j = -0.5+0.86603i"
+
+Notice that this affects also the return values of the
+C<display_format> methods: in list context the whole parameter hash
+will be returned, as opposed to only the style parameter value.
+This is a potential incompatibility with earlier versions if you
+have been calling the C<display_format> method in list context.
+
+The second new display parameter is C<"polar_pretty_print">, which can
+be set to true or false, the default being true.  See the previous
+section for what this means.
+
+=head1 USAGE
+
+Thanks to overloading, the handling of arithmetics with complex numbers
+is simple and almost transparent.
+
+Here are some examples:
+
+	use Math::Complex;
+
+	$j = cplxe(1, 2*pi/3);	# $j ** 3 == 1
+	print "j = $j, j**3 = ", $j ** 3, "\n";
+	print "1 + j + j**2 = ", 1 + $j + $j**2, "\n";
+
+	$z = -16 + 0*i;			# Force it to be a complex
+	print "sqrt($z) = ", sqrt($z), "\n";
+
+	$k = exp(i * 2*pi/3);
+	print "$j - $k = ", $j - $k, "\n";
+
+	$z->Re(3);			# Re, Im, arg, abs,
+	$j->arg(2);			# (the last two aka rho, theta)
+					# can be used also as mutators.
+
+=head1 CONSTANTS
+
+=head2 PI
+
+The constant C<pi> and some handy multiples of it (pi2, pi4,
+and pip2 (pi/2) and pip4 (pi/4)) are also available if separately
+exported:
+
+    use Math::Complex ':pi'; 
+    $third_of_circle = pi2 / 3;
+
+=head2 Inf
+
+The floating point infinity can be exported as a subroutine Inf():
+
+    use Math::Complex qw(Inf sinh);
+    my $AlsoInf = Inf() + 42;
+    my $AnotherInf = sinh(1e42);
+    print "$AlsoInf is $AnotherInf\n" if $AlsoInf == $AnotherInf;
+
+Note that the stringified form of infinity varies between platforms:
+it can be for example any of
+
+   inf
+   infinity
+   INF
+   1.#INF
+
+or it can be something else. 
+
+Also note that in some platforms trying to use the infinity in
+arithmetic operations may result in Perl crashing because using
+an infinity causes SIGFPE or its moral equivalent to be sent.
+The way to ignore this is
+
+  local $SIG{FPE} = sub { };
+
+=head1 ERRORS DUE TO DIVISION BY ZERO OR LOGARITHM OF ZERO
+
+The division (/) and the following functions
+
+	log	ln	log10	logn
+	tan	sec	csc	cot
+	atan	asec	acsc	acot
+	tanh	sech	csch	coth
+	atanh	asech	acsch	acoth
+
+cannot be computed for all arguments because that would mean dividing
+by zero or taking logarithm of zero. These situations cause fatal
+runtime errors looking like this
+
+	cot(0): Division by zero.
+	(Because in the definition of cot(0), the divisor sin(0) is 0)
+	Died at ...
+
+or
+
+	atanh(-1): Logarithm of zero.
+	Died at...
+
+For the C<csc>, C<cot>, C<asec>, C<acsc>, C<acot>, C<csch>, C<coth>,
+C<asech>, C<acsch>, the argument cannot be C<0> (zero).  For the
+logarithmic functions and the C<atanh>, C<acoth>, the argument cannot
+be C<1> (one).  For the C<atanh>, C<acoth>, the argument cannot be
+C<-1> (minus one).  For the C<atan>, C<acot>, the argument cannot be
+C<i> (the imaginary unit).  For the C<atan>, C<acoth>, the argument
+cannot be C<-i> (the negative imaginary unit).  For the C<tan>,
+C<sec>, C<tanh>, the argument cannot be I<pi/2 + k * pi>, where I<k>
+is any integer.  atan2(0, 0) is undefined, and if the complex arguments
+are used for atan2(), a division by zero will happen if z1**2+z2**2 == 0.
+
+Note that because we are operating on approximations of real numbers,
+these errors can happen when merely `too close' to the singularities
+listed above.
+
+=head1 ERRORS DUE TO INDIGESTIBLE ARGUMENTS
+
+The C<make> and C<emake> accept both real and complex arguments.
+When they cannot recognize the arguments they will die with error
+messages like the following
+
+    Math::Complex::make: Cannot take real part of ...
+    Math::Complex::make: Cannot take real part of ...
+    Math::Complex::emake: Cannot take rho of ...
+    Math::Complex::emake: Cannot take theta of ...
+
+=head1 BUGS
+
+Saying C<use Math::Complex;> exports many mathematical routines in the
+caller environment and even overrides some (C<sqrt>, C<log>, C<atan2>).
+This is construed as a feature by the Authors, actually... ;-)
+
+All routines expect to be given real or complex numbers. Don't attempt to
+use BigFloat, since Perl has currently no rule to disambiguate a '+'
+operation (for instance) between two overloaded entities.
+
+In Cray UNICOS there is some strange numerical instability that results
+in root(), cos(), sin(), cosh(), sinh(), losing accuracy fast.  Beware.
+The bug may be in UNICOS math libs, in UNICOS C compiler, in Math::Complex.
+Whatever it is, it does not manifest itself anywhere else where Perl runs.
+
+=head1 SEE ALSO
+
+L<Math::Trig>
+
+=head1 AUTHORS
+
+Daniel S. Lewart <F<lewart!at!uiuc.edu>>,
+Jarkko Hietaniemi <F<jhi!at!iki.fi>>,
+Raphael Manfredi <F<Raphael_Manfredi!at!pobox.com>>,
+Zefram <zefram@fysh.org>
+
+=head1 LICENSE
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself. 
+
+=cut
+
+1;
+
+# eof

git/usr/share/perl5/core_perl/Math/Trig.pm

@@ -0,0 +1,773 @@
+#
+# Trigonometric functions, mostly inherited from Math::Complex.
+# -- Jarkko Hietaniemi, since April 1997
+# -- Raphael Manfredi, September 1996 (indirectly: because of Math::Complex)
+#
+
+package Math::Trig;
+
+{ use 5.006; }
+use strict;
+
+use Math::Complex 1.59;
+use Math::Complex qw(:trig :pi);
+require Exporter;
+
+our @ISA = qw(Exporter);
+
+our $VERSION = 1.63;
+
+my @angcnv = qw(rad2deg rad2grad
+		deg2rad deg2grad
+		grad2rad grad2deg);
+
+my @areal = qw(asin_real acos_real);
+
+our @EXPORT = (@{$Math::Complex::EXPORT_TAGS{'trig'}},
+	   @angcnv, @areal);
+
+my @rdlcnv = qw(cartesian_to_cylindrical
+		cartesian_to_spherical
+		cylindrical_to_cartesian
+		cylindrical_to_spherical
+		spherical_to_cartesian
+		spherical_to_cylindrical);
+
+my @greatcircle = qw(
+		     great_circle_distance
+		     great_circle_direction
+		     great_circle_bearing
+		     great_circle_waypoint
+		     great_circle_midpoint
+		     great_circle_destination
+		    );
+
+my @pi = qw(pi pi2 pi4 pip2 pip4);
+
+our @EXPORT_OK = (@rdlcnv, @greatcircle, @pi, 'Inf');
+
+# See e.g. the following pages:
+# https://www.movable-type.co.uk/scripts/latlong.html
+# https://edwilliams.org/avform.htm
+# https://en.wikipedia.org/wiki/Great-circle_distance
+
+our %EXPORT_TAGS = ('radial' => [ @rdlcnv ],
+	        'great_circle' => [ @greatcircle ],
+	        'pi'     => [ @pi ]);
+
+sub _DR  () { pi2/360 }
+sub _RD  () { 360/pi2 }
+sub _DG  () { 400/360 }
+sub _GD  () { 360/400 }
+sub _RG  () { 400/pi2 }
+sub _GR  () { pi2/400 }
+
+#
+# Truncating remainder.
+#
+
+sub _remt ($$) {
+    # Oh yes, POSIX::fmod() would be faster. Possibly. If it is available.
+    $_[0] - $_[1] * int($_[0] / $_[1]);
+}
+
+#
+# Angle conversions.
+#
+
+sub rad2rad($)     { _remt($_[0], pi2) }
+
+sub deg2deg($)     { _remt($_[0], 360) }
+
+sub grad2grad($)   { _remt($_[0], 400) }
+
+sub rad2deg ($;$)  { my $d = _RD * $_[0]; $_[1] ? $d : deg2deg($d) }
+
+sub deg2rad ($;$)  { my $d = _DR * $_[0]; $_[1] ? $d : rad2rad($d) }
+
+sub grad2deg ($;$) { my $d = _GD * $_[0]; $_[1] ? $d : deg2deg($d) }
+
+sub deg2grad ($;$) { my $d = _DG * $_[0]; $_[1] ? $d : grad2grad($d) }
+
+sub rad2grad ($;$) { my $d = _RG * $_[0]; $_[1] ? $d : grad2grad($d) }
+
+sub grad2rad ($;$) { my $d = _GR * $_[0]; $_[1] ? $d : rad2rad($d) }
+
+#
+# acos and asin functions which always return a real number
+#
+
+sub acos_real {
+    return 0  if $_[0] >=  1;
+    return pi if $_[0] <= -1;
+    return acos($_[0]);
+}
+
+sub asin_real {
+    return  &pip2 if $_[0] >=  1;
+    return -&pip2 if $_[0] <= -1;
+    return asin($_[0]);
+}
+
+sub cartesian_to_spherical {
+    my ( $x, $y, $z ) = @_;
+
+    my $rho = sqrt( $x * $x + $y * $y + $z * $z );
+
+    return ( $rho,
+             atan2( $y, $x ),
+             $rho ? acos_real( $z / $rho ) : 0 );
+}
+
+sub spherical_to_cartesian {
+    my ( $rho, $theta, $phi ) = @_;
+
+    return ( $rho * cos( $theta ) * sin( $phi ),
+             $rho * sin( $theta ) * sin( $phi ),
+             $rho * cos( $phi   ) );
+}
+
+sub spherical_to_cylindrical {
+    my ( $x, $y, $z ) = spherical_to_cartesian( @_ );
+
+    return ( sqrt( $x * $x + $y * $y ), $_[1], $z );
+}
+
+sub cartesian_to_cylindrical {
+    my ( $x, $y, $z ) = @_;
+
+    return ( sqrt( $x * $x + $y * $y ), atan2( $y, $x ), $z );
+}
+
+sub cylindrical_to_cartesian {
+    my ( $rho, $theta, $z ) = @_;
+
+    return ( $rho * cos( $theta ), $rho * sin( $theta ), $z );
+}
+
+sub cylindrical_to_spherical {
+    return ( cartesian_to_spherical( cylindrical_to_cartesian( @_ ) ) );
+}
+
+sub great_circle_distance {
+    my ( $theta0, $phi0, $theta1, $phi1, $rho ) = @_;
+
+    $rho = 1 unless defined $rho; # Default to the unit sphere.
+
+    my $dphi   = $phi1 - $phi0;
+    my $dtheta = $theta1 - $theta0;
+
+    # A formula that is accurate for all distances is the following special
+    # case of the Vincenty formula for an ellipsoid with equal major and minor
+    # axes.  See
+    # https://en.wikipedia.org/wiki/Great-circle_distance#Computational_formulas
+
+    my $c1 = sin($phi1) * sin($dtheta);
+    my $c2 = sin($phi1) * cos($dtheta);
+    my $c3 = sin($phi0) * cos($phi1) - cos($phi0) * $c2;
+    my $c4 = cos($phi0) * cos($phi1) + sin($phi0) * $c2;
+    return $rho * atan2(sqrt($c1 * $c1 + $c3 * $c3), $c4);
+}
+
+sub great_circle_direction {
+    my ( $theta0, $phi0, $theta1, $phi1 ) = @_;
+
+    my $lat0 = pip2 - $phi0;
+    my $lat1 = pip2 - $phi1;
+
+    return rad2rad(pi2 -
+	atan2(sin($theta0-$theta1) * cos($lat1),
+		cos($lat0) * sin($lat1) -
+		    sin($lat0) * cos($lat1) * cos($theta0-$theta1)));
+}
+
+*great_circle_bearing         = \&great_circle_direction;
+
+sub great_circle_waypoint {
+    my ( $theta0, $phi0, $theta1, $phi1, $point ) = @_;
+
+    $point = 0.5 unless defined $point;
+
+    my $d = great_circle_distance( $theta0, $phi0, $theta1, $phi1 );
+
+    return undef if $d == pi;
+
+    my $sd = sin($d);
+
+    return ($theta0, $phi0) if $sd == 0;
+
+    my $A = sin((1 - $point) * $d) / $sd;
+    my $B = sin(     $point  * $d) / $sd;
+
+    my $lat0 = pip2 - $phi0;
+    my $lat1 = pip2 - $phi1;
+
+    my $x = $A * cos($lat0) * cos($theta0) + $B * cos($lat1) * cos($theta1);
+    my $y = $A * cos($lat0) * sin($theta0) + $B * cos($lat1) * sin($theta1);
+    my $z = $A * sin($lat0)                + $B * sin($lat1);
+
+    my $theta = atan2($y, $x);
+    my $phi   = acos_real($z);
+
+    return ($theta, $phi);
+}
+
+sub great_circle_midpoint {
+    great_circle_waypoint(@_[0..3], 0.5);
+}
+
+sub great_circle_destination {
+    my ( $theta0, $phi0, $dir0, $dst ) = @_;
+
+    my $lat0 = pip2 - $phi0;
+
+    my $phi1   = asin_real(sin($lat0)*cos($dst) +
+			   cos($lat0)*sin($dst)*cos($dir0));
+
+    my $theta1 = $theta0 + atan2(sin($dir0)*sin($dst)*cos($lat0),
+				 cos($dst)-sin($lat0)*sin($phi1));
+
+    my $dir1 = great_circle_bearing($theta1, $phi1, $theta0, $phi0) + pi;
+
+    $dir1 -= pi2 if $dir1 > pi2;
+
+    return ($theta1, $phi1, $dir1);
+}
+
+1;
+
+__END__
+=pod
+
+=head1 NAME
+
+Math::Trig - trigonometric functions
+
+=head1 SYNOPSIS
+
+    use Math::Trig;
+
+    $x = tan(0.9);
+    $y = acos(3.7);
+    $z = asin(2.4);
+
+    $halfpi = pi/2;
+
+    $rad = deg2rad(120);
+
+    # Import constants pi2, pi4, pip2, pip4 (2*pi, 4*pi, pi/2, pi/4).
+    use Math::Trig ':pi';
+
+    # Import the conversions between cartesian/spherical/cylindrical.
+    use Math::Trig ':radial';
+
+        # Import the great circle formulas.
+    use Math::Trig ':great_circle';
+
+=head1 DESCRIPTION
+
+C<Math::Trig> defines many trigonometric functions not defined by the
+core Perl which defines only the C<sin()> and C<cos()>.  The constant
+B<pi> is also defined as are a few convenience functions for angle
+conversions, and I<great circle formulas> for spherical movement.
+
+=head1 TRIGONOMETRIC FUNCTIONS
+
+The tangent
+
+=over 4
+
+=item B<tan>
+
+=back
+
+The cofunctions of the sine, cosine, and tangent (cosec/csc and cotan/cot
+are aliases)
+
+B<csc>, B<cosec>, B<sec>, B<sec>, B<cot>, B<cotan>
+
+The arcus (also known as the inverse) functions of the sine, cosine,
+and tangent
+
+B<asin>, B<acos>, B<atan>
+
+The principal value of the arc tangent of y/x
+
+B<atan2>(y, x)
+
+The arcus cofunctions of the sine, cosine, and tangent (acosec/acsc
+and acotan/acot are aliases).  Note that atan2(0, 0) is not well-defined.
+
+B<acsc>, B<acosec>, B<asec>, B<acot>, B<acotan>
+
+The hyperbolic sine, cosine, and tangent
+
+B<sinh>, B<cosh>, B<tanh>
+
+The cofunctions of the hyperbolic sine, cosine, and tangent (cosech/csch
+and cotanh/coth are aliases)
+
+B<csch>, B<cosech>, B<sech>, B<coth>, B<cotanh>
+
+The area (also known as the inverse) functions of the hyperbolic
+sine, cosine, and tangent
+
+B<asinh>, B<acosh>, B<atanh>
+
+The area cofunctions of the hyperbolic sine, cosine, and tangent
+(acsch/acosech and acoth/acotanh are aliases)
+
+B<acsch>, B<acosech>, B<asech>, B<acoth>, B<acotanh>
+
+The trigonometric constant B<pi> and some of handy multiples
+of it are also defined.
+
+B<pi, pi2, pi4, pip2, pip4>
+
+=head2 ERRORS DUE TO DIVISION BY ZERO
+
+The following functions
+
+    acoth
+    acsc
+    acsch
+    asec
+    asech
+    atanh
+    cot
+    coth
+    csc
+    csch
+    sec
+    sech
+    tan
+    tanh
+
+cannot be computed for all arguments because that would mean dividing
+by zero or taking logarithm of zero. These situations cause fatal
+runtime errors looking like this
+
+    cot(0): Division by zero.
+    (Because in the definition of cot(0), the divisor sin(0) is 0)
+    Died at ...
+
+or
+
+    atanh(-1): Logarithm of zero.
+    Died at...
+
+For the C<csc>, C<cot>, C<asec>, C<acsc>, C<acot>, C<csch>, C<coth>,
+C<asech>, C<acsch>, the argument cannot be C<0> (zero).  For the
+C<atanh>, C<acoth>, the argument cannot be C<1> (one).  For the
+C<atanh>, C<acoth>, the argument cannot be C<-1> (minus one).  For the
+C<tan>, C<sec>, C<tanh>, C<sech>, the argument cannot be I<pi/2 + k *
+pi>, where I<k> is any integer.
+
+Note that atan2(0, 0) is not well-defined.
+
+=head2 SIMPLE (REAL) ARGUMENTS, COMPLEX RESULTS
+
+Please note that some of the trigonometric functions can break out
+from the B<real axis> into the B<complex plane>. For example
+C<asin(2)> has no definition for plain real numbers but it has
+definition for complex numbers.
+
+In Perl terms this means that supplying the usual Perl numbers (also
+known as scalars, please see L<perldata>) as input for the
+trigonometric functions might produce as output results that no more
+are simple real numbers: instead they are complex numbers.
+
+The C<Math::Trig> handles this by using the C<Math::Complex> package
+which knows how to handle complex numbers, please see L<Math::Complex>
+for more information. In practice you need not to worry about getting
+complex numbers as results because the C<Math::Complex> takes care of
+details like for example how to display complex numbers. For example:
+
+    print asin(2), "\n";
+
+should produce something like this (take or leave few last decimals):
+
+    1.5707963267949-1.31695789692482i
+
+That is, a complex number with the real part of approximately C<1.571>
+and the imaginary part of approximately C<-1.317>.
+
+=head1 PLANE ANGLE CONVERSIONS
+
+(Plane, 2-dimensional) angles may be converted with the following functions.
+
+=over
+
+=item deg2rad
+
+    $radians  = deg2rad($degrees);
+
+=item grad2rad
+
+    $radians  = grad2rad($gradians);
+
+=item rad2deg
+
+    $degrees  = rad2deg($radians);
+
+=item grad2deg
+
+    $degrees  = grad2deg($gradians);
+
+=item deg2grad
+
+    $gradians = deg2grad($degrees);
+
+=item rad2grad
+
+    $gradians = rad2grad($radians);
+
+=back
+
+The full circle is 2 I<pi> radians or I<360> degrees or I<400> gradians.
+The result is by default wrapped to be inside the [0, {2pi,360,400}) circle.
+If you don't want this, supply a true second argument:
+
+    $zillions_of_radians  = deg2rad($zillions_of_degrees, 1);
+    $negative_degrees     = rad2deg($negative_radians, 1);
+
+You can also do the wrapping explicitly by rad2rad(), deg2deg(), and
+grad2grad().
+
+=over 4
+
+=item rad2rad
+
+    $radians_wrapped_by_2pi = rad2rad($radians);
+
+=item deg2deg
+
+    $degrees_wrapped_by_360 = deg2deg($degrees);
+
+=item grad2grad
+
+    $gradians_wrapped_by_400 = grad2grad($gradians);
+
+=back
+
+=head1 RADIAL COORDINATE CONVERSIONS
+
+B<Radial coordinate systems> are the B<spherical> and the B<cylindrical>
+systems, explained shortly in more detail.
+
+You can import radial coordinate conversion functions by using the
+C<:radial> tag:
+
+    use Math::Trig ':radial';
+
+    ($rho, $theta, $z)     = cartesian_to_cylindrical($x, $y, $z);
+    ($rho, $theta, $phi)   = cartesian_to_spherical($x, $y, $z);
+    ($x, $y, $z)           = cylindrical_to_cartesian($rho, $theta, $z);
+    ($rho_s, $theta, $phi) = cylindrical_to_spherical($rho_c, $theta, $z);
+    ($x, $y, $z)           = spherical_to_cartesian($rho, $theta, $phi);
+    ($rho_c, $theta, $z)   = spherical_to_cylindrical($rho_s, $theta, $phi);
+
+B<All angles are in radians>.
+
+=head2 COORDINATE SYSTEMS
+
+B<Cartesian> coordinates are the usual rectangular I<(x, y, z)>-coordinates.
+
+Spherical coordinates, I<(rho, theta, phi)>, are three-dimensional
+coordinates which define a point in three-dimensional space.  They are
+based on a sphere surface.  The radius of the sphere is B<rho>, also
+known as the I<radial> coordinate.  The angle in the I<xy>-plane
+(around the I<z>-axis) is B<theta>, also known as the I<azimuthal>
+coordinate.  The angle from the I<z>-axis is B<phi>, also known as the
+I<polar> coordinate.  The North Pole is therefore I<rho, 0, 0>, and
+the Gulf of Guinea (think of the missing big chunk of Africa) I<rho,
+0, pi/2>.  In geographical terms I<phi> is latitude (northward
+positive, southward negative) and I<theta> is longitude (eastward
+positive, westward negative).
+
+B<BEWARE>: some texts define I<theta> and I<phi> the other way round,
+some texts define the I<phi> to start from the horizontal plane, some
+texts use I<r> in place of I<rho>.
+
+Cylindrical coordinates, I<(rho, theta, z)>, are three-dimensional
+coordinates which define a point in three-dimensional space.  They are
+based on a cylinder surface.  The radius of the cylinder is B<rho>,
+also known as the I<radial> coordinate.  The angle in the I<xy>-plane
+(around the I<z>-axis) is B<theta>, also known as the I<azimuthal>
+coordinate.  The third coordinate is the I<z>, pointing up from the
+B<theta>-plane.
+
+=head2 3-D ANGLE CONVERSIONS
+
+Conversions to and from spherical and cylindrical coordinates are
+available.  Please notice that the conversions are not necessarily
+reversible because of the equalities like I<pi> angles being equal to
+I<-pi> angles.
+
+=over 4
+
+=item cartesian_to_cylindrical
+
+    ($rho, $theta, $z) = cartesian_to_cylindrical($x, $y, $z);
+
+=item cartesian_to_spherical
+
+    ($rho, $theta, $phi) = cartesian_to_spherical($x, $y, $z);
+
+=item cylindrical_to_cartesian
+
+    ($x, $y, $z) = cylindrical_to_cartesian($rho, $theta, $z);
+
+=item cylindrical_to_spherical
+
+    ($rho_s, $theta, $phi) = cylindrical_to_spherical($rho_c, $theta, $z);
+
+Notice that when C<$z> is not 0 C<$rho_s> is not equal to C<$rho_c>.
+
+=item spherical_to_cartesian
+
+    ($x, $y, $z) = spherical_to_cartesian($rho, $theta, $phi);
+
+=item spherical_to_cylindrical
+
+    ($rho_c, $theta, $z) = spherical_to_cylindrical($rho_s, $theta, $phi);
+
+Notice that when C<$z> is not 0 C<$rho_c> is not equal to C<$rho_s>.
+
+=back
+
+=head1 GREAT CIRCLE DISTANCES AND DIRECTIONS
+
+A great circle is section of a circle that contains the circle
+diameter: the shortest distance between two (non-antipodal) points on
+the spherical surface goes along the great circle connecting those two
+points.
+
+=head2 great_circle_distance
+
+Returns the great circle distance between two points on a sphere.
+
+    $distance = great_circle_distance($theta0, $phi0, $theta1, $phi1, [, $rho]);
+
+Where ($theta0, $phi0) and ($theta1, $phi1) are the spherical coordinates of
+the two points, respectively. The distance is in C<$rho> units. The C<$rho>
+is optional. It defaults to 1 (the unit sphere).
+
+If you are using geographic coordinates, latitude and longitude, you need to
+adjust for the fact that latitude is zero at the equator increasing towards
+the north and decreasing towards the south. Assuming ($lat0, $lon0) and
+($lat1, $lon1) are the geographic coordinates in radians of the two points,
+the distance can be computed with
+
+  $distance = great_circle_distance($lon0, pi/2 - $lat0,
+                                    $lon1, pi/2 - $lat1, $rho);
+
+=head2 great_circle_direction
+
+The direction you must follow the great circle (also known as I<bearing>)
+can be computed by the great_circle_direction() function:
+
+  use Math::Trig 'great_circle_direction';
+
+  $direction = great_circle_direction($theta0, $phi0, $theta1, $phi1);
+
+=head2 great_circle_bearing
+
+Alias 'great_circle_bearing' for 'great_circle_direction' is also available.
+
+  use Math::Trig 'great_circle_bearing';
+
+  $direction = great_circle_bearing($theta0, $phi0, $theta1, $phi1);
+
+The result of great_circle_direction is in radians, zero indicating
+straight north, pi or -pi straight south, pi/2 straight west, and
+-pi/2 straight east.
+
+=head2 great_circle_destination
+
+You can inversely compute the destination if you know the
+starting point, direction, and distance:
+
+  use Math::Trig 'great_circle_destination';
+
+  # $diro is the original direction,
+  # for example from great_circle_bearing().
+  # $distance is the angular distance in radians,
+  # for example from great_circle_distance().
+  # $thetad and $phid are the destination coordinates,
+  # $dird is the final direction at the destination.
+
+  ($thetad, $phid, $dird) =
+    great_circle_destination($theta, $phi, $diro, $distance);
+
+or the midpoint if you know the end points:
+
+=head2 great_circle_midpoint
+
+  use Math::Trig 'great_circle_midpoint';
+
+  ($thetam, $phim) =
+    great_circle_midpoint($theta0, $phi0, $theta1, $phi1);
+
+The great_circle_midpoint() is just a special case of
+
+=head2 great_circle_waypoint
+
+  use Math::Trig 'great_circle_waypoint';
+
+  ($thetai, $phii) =
+    great_circle_waypoint($theta0, $phi0, $theta1, $phi1, $way);
+
+Where $way indicates the position of the waypoint along the great
+circle arc through the starting point ($theta0, $phi0) and the end
+point ($theta1, $phi1) relative to the distance from the starting
+point to the end point. So $way = 0 gives the starting point, $way = 1
+gives the end point, $way < 0 gives a point "behind" the starting
+point, and $way > 1 gives a point beyond the end point. $way defaults
+to 0.5 if not given.
+
+Note that antipodal points (where their distance is I<pi> radians) do
+not have unique waypoints between them, and therefore C<undef> is
+returned in such cases.  If the points are the same, so the distance
+between them is zero, all waypoints are identical to the starting/end
+point.
+
+The thetas, phis, direction, and distance in the above are all in
+radians.
+
+You can import all the great circle formulas by
+
+  use Math::Trig ':great_circle';
+
+Notice that the resulting directions might be somewhat surprising if
+you are looking at a flat worldmap: in such map projections the great
+circles quite often do not look like the shortest routes --  but for
+example the shortest possible routes from Europe or North America to
+Asia do often cross the polar regions.  (The common Mercator projection
+does B<not> show great circles as straight lines: straight lines in the
+Mercator projection are lines of constant bearing.)
+
+=head1 EXAMPLES
+
+To calculate the distance between London (51.3N 0.5W) and Tokyo
+(35.7N 139.8E) in kilometers:
+
+    use Math::Trig qw(great_circle_distance deg2rad);
+
+    # Notice the 90 - latitude: phi zero is at the North Pole.
+    sub NESW { deg2rad($_[0]), deg2rad(90 - $_[1]) }
+    my @L = NESW( -0.5, 51.3);
+    my @T = NESW(139.8, 35.7);
+    my $km = great_circle_distance(@L, @T, 6378); # About 9600 km.
+
+The direction you would have to go from London to Tokyo (in radians,
+straight north being zero, straight east being pi/2).
+
+    use Math::Trig qw(great_circle_direction);
+
+    my $rad = great_circle_direction(@L, @T); # About 0.547 or 0.174 pi.
+
+The midpoint between London and Tokyo being
+
+    use Math::Trig qw(great_circle_midpoint rad2deg);
+
+    my @M = great_circle_midpoint(@L, @T);
+    sub SWNE { rad2deg( $_[0] ), 90 - rad2deg( $_[1] ) }
+    my @lonlat = SWNE(@M);
+
+or about 69 N 89 E, on the Putorana Plateau of Siberia.
+
+B<NOTE>: you B<cannot> get from A to B like this:
+
+   Dist = great_circle_distance(A, B)
+   Dir  = great_circle_direction(A, B)
+   C    = great_circle_destination(A, Dist, Dir)
+
+and expect C to be B, because the bearing constantly changes when
+going from A to B (except in some special case like the meridians or
+the circles of latitudes) and in great_circle_destination() one gives
+a B<constant> bearing to follow.
+
+=head2 CAVEAT FOR GREAT CIRCLE FORMULAS
+
+The answers may be off by few percentages because of the irregular
+(slightly aspherical) form of the Earth.  The errors are at worst
+about 0.55%, but generally below 0.3%.
+
+=head2 Real-valued asin and acos
+
+For small inputs asin() and acos() may return complex numbers even
+when real numbers would be enough and correct, this happens because of
+floating-point inaccuracies.  You can see these inaccuracies for
+example by trying theses:
+
+  print cos(1e-6)**2+sin(1e-6)**2 - 1,"\n";
+  printf "%.20f", cos(1e-6)**2+sin(1e-6)**2,"\n";
+
+which will print something like this
+
+  -1.11022302462516e-16
+  0.99999999999999988898
+
+even though the expected results are of course exactly zero and one.
+The formulas used to compute asin() and acos() are quite sensitive to
+this, and therefore they might accidentally slip into the complex
+plane even when they should not.  To counter this there are two
+interfaces that are guaranteed to return a real-valued output.
+
+=over 4
+
+=item asin_real
+
+    use Math::Trig qw(asin_real);
+
+    $real_angle = asin_real($input_sin);
+
+Return a real-valued arcus sine if the input is between [-1, 1],
+B<inclusive> the endpoints.  For inputs greater than one, pi/2
+is returned.  For inputs less than minus one, -pi/2 is returned.
+
+=item acos_real
+
+    use Math::Trig qw(acos_real);
+
+    $real_angle = acos_real($input_cos);
+
+Return a real-valued arcus cosine if the input is between [-1, 1],
+B<inclusive> the endpoints.  For inputs greater than one, zero
+is returned.  For inputs less than minus one, pi is returned.
+
+=back
+
+=head1 BUGS
+
+Saying C<use Math::Trig;> exports many mathematical routines in the
+caller environment and even overrides some (C<sin>, C<cos>).  This is
+construed as a feature by the Authors, actually... ;-)
+
+The code is not optimized for speed, especially because we use
+C<Math::Complex> and thus go quite near complex numbers while doing
+the computations even when the arguments are not. This, however,
+cannot be completely avoided if we want things like C<asin(2)> to give
+an answer instead of giving a fatal runtime error.
+
+Do not attempt navigation using these formulas.
+
+=head1 SEE ALSO
+
+L<Math::Complex>
+
+=head1 AUTHORS
+
+Jarkko Hietaniemi <F<jhi!at!iki.fi>>,
+Raphael Manfredi <F<Raphael_Manfredi!at!pobox.com>>,
+Zefram <zefram@fysh.org>
+
+=head1 LICENSE
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself. 
+
+=cut
+
+# eof

git/usr/share/perl5/core_perl/Memoize/AnyDBM_File.pm

@@ -0,0 +1,37 @@
+use strict; use warnings;
+
+package Memoize::AnyDBM_File;
+our $VERSION = '1.17';
+
+our @ISA = qw(DB_File GDBM_File Memoize::NDBM_File SDBM_File ODBM_File) unless @ISA;
+
+for my $mod (@ISA) {
+  if (eval "require $mod") {
+    $mod = 'NDBM_File'
+		if $mod eq 'Memoize::NDBM_File'
+		and eval { NDBM_File->VERSION( '1.16' ) };
+    print STDERR "AnyDBM_File => Selected $mod.\n" if our $Verbose;
+    @ISA = $mod;
+    return 1;
+  }
+}
+
+die "No DBM package was successfully found or installed";
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Memoize::AnyDBM_File - glue to provide EXISTS for AnyDBM_File for Storable use
+
+=head1 DESCRIPTION
+
+This class does the same thing as L<AnyDBM_File>, except that instead of
+L<NDBM_File> itself it loads L<Memoize::NDBM_File> if L<NDBM_File> lacks
+L<EXISTS|perltie/C<EXISTS>> support.
+
+Code which requires perl 5.37.3 or newer should simply use L<AnyBDM_File> directly.
+
+=cut

git/usr/share/perl5/core_perl/Memoize/Expire.pm

@@ -0,0 +1,352 @@
+use strict; use warnings;
+
+package Memoize::Expire;
+our $VERSION = '1.17';
+
+use Carp;
+our $DEBUG;
+
+# The format of the metadata is:
+# (4-byte number of last-access-time)  (For LRU when I implement it)
+# (4-byte expiration time: unsigned seconds-since-unix-epoch)
+# (2-byte number-of-uses-before-expire)
+
+BEGIN {
+  eval {require Time::HiRes};
+  unless ($@) {
+    Time::HiRes->import('time');
+  }
+}
+
+sub TIEHASH {
+  my ($package, %args) = @_;
+  my %cache;
+  if ($args{TIE}) {
+    my ($module, @opts) = @{$args{TIE}};
+    my $modulefile = $module . '.pm';
+    $modulefile =~ s{::}{/}g;
+    eval { require $modulefile };
+    if ($@) {
+      croak "Memoize::Expire: Couldn't load hash tie module `$module': $@; aborting";
+    }
+    my $rc = (tie %cache => $module, @opts);
+    unless ($rc) {
+      croak "Memoize::Expire: Couldn't tie hash to `$module': $@; aborting";
+    }
+  }
+  $args{LIFETIME} ||= 0;
+  $args{NUM_USES} ||= 0;
+  $args{C} = delete $args{HASH} || \%cache;
+  bless \%args => $package;
+}
+
+sub STORE {
+  $DEBUG and print STDERR " >> Store $_[1] $_[2]\n";
+  my ($self, $key, $value) = @_;
+  my $expire_time = $self->{LIFETIME} > 0 ? $self->{LIFETIME} + time : 0;
+  # The call that results in a value to store into the cache is the
+  # first of the NUM_USES allowed calls.
+  my $header = _make_header(time, $expire_time, $self->{NUM_USES}-1);
+  @{$self->{C}}{"H$key", "V$key"} = ($header, $value);
+  $value;
+}
+
+sub FETCH {
+  $DEBUG and print STDERR " >> Fetch cached value for $_[1]\n";
+  my ($last_access, $expire_time, $num_uses_left) = _get_header($_[0]{C}{"H$_[1]"});
+  $DEBUG and print STDERR " >>   (ttl: ", ($expire_time-time()), ", nuses: $num_uses_left)\n";
+  $_[0]{C}{"H$_[1]"} = _make_header(time, $expire_time, --$num_uses_left);
+  $_[0]{C}{"V$_[1]"};
+}
+
+sub EXISTS {
+  $DEBUG and print STDERR " >> Exists $_[1]\n";
+  unless (exists $_[0]{C}{"V$_[1]"}) {
+    $DEBUG and print STDERR "    Not in underlying hash at all.\n";
+    return 0;
+  }
+  my $item = $_[0]{C}{"H$_[1]"};
+  my ($last_access, $expire_time, $num_uses_left) = _get_header($item);
+  my $ttl = $expire_time - time;
+  if ($DEBUG) {
+    $_[0]{LIFETIME} and print STDERR "    Time to live for this item: $ttl\n";
+    $_[0]{NUM_USES} and print STDERR "    Uses remaining: $num_uses_left\n";
+  }
+  if (   (! $_[0]{LIFETIME} || $expire_time > time)
+      && (! $_[0]{NUM_USES} || $num_uses_left > 0 )) {
+	    $DEBUG and print STDERR "    (Still good)\n";
+    return 1;
+  } else {
+    $DEBUG and print STDERR "    (Expired)\n";
+    return 0;
+  }
+}
+
+sub FIRSTKEY {
+  scalar keys %{$_[0]{C}};
+  &NEXTKEY;
+}
+
+sub NEXTKEY {
+  while (defined(my $key = each %{$_[0]{C}})) {
+    return substr $key, 1 if 'V' eq substr $key, 0, 1;
+  }
+  undef;
+}
+
+# Arguments: last access time, expire time, number of uses remaining
+sub _make_header {
+  pack "N N n", @_;
+}
+
+# Return last access time, expire time, number of uses remaining
+sub _get_header  {
+  unpack "N N n", substr($_[0], 0, 10);
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME 
+
+Memoize::Expire - Plug-in module for automatic expiration of memoized values
+
+=head1 SYNOPSIS
+
+  use Memoize;
+  use Memoize::Expire;
+  tie my %cache => 'Memoize::Expire',
+	  	     LIFETIME => $lifetime,    # In seconds
+		     NUM_USES => $n_uses;
+
+  memoize 'function', SCALAR_CACHE => [HASH => \%cache ];
+
+=head1 DESCRIPTION
+
+Memoize::Expire is a plug-in module for Memoize.  It allows the cached
+values for memoized functions to expire automatically.  This manual
+assumes you are already familiar with the Memoize module.  If not, you
+should study that manual carefully first, paying particular attention
+to the HASH feature.
+
+Memoize::Expire is a layer of software that you can insert in between
+Memoize itself and whatever underlying package implements the cache.
+The layer presents a hash variable whose values expire whenever they
+get too old, have been used too often, or both. You tell C<Memoize> to
+use this forgetful hash as its cache instead of the default, which is
+an ordinary hash.
+
+To specify a real-time timeout, supply the C<LIFETIME> option with a
+numeric value.  Cached data will expire after this many seconds, and
+will be looked up afresh when it expires.  When a data item is looked
+up afresh, its lifetime is reset.
+
+If you specify C<NUM_USES> with an argument of I<n>, then each cached
+data item will be discarded and looked up afresh after the I<n>th time
+you access it.  When a data item is looked up afresh, its number of
+uses is reset.
+
+If you specify both arguments, data will be discarded from the cache
+when either expiration condition holds.
+
+Memoize::Expire uses a real hash internally to store the cached data.
+You can use the C<HASH> option to Memoize::Expire to supply a tied
+hash in place of the ordinary hash that Memoize::Expire will normally
+use.  You can use this feature to add Memoize::Expire as a layer in
+between a persistent disk hash and Memoize.  If you do this, you get a
+persistent disk cache whose entries expire automatically.  For
+example:
+
+  #   Memoize
+  #      |
+  #   Memoize::Expire  enforces data expiration policy
+  #      |
+  #   DB_File  implements persistence of data in a disk file
+  #      |
+  #   Disk file
+
+  use Memoize;
+  use Memoize::Expire;
+  use DB_File;
+
+  # Set up persistence
+  tie my %disk_cache => 'DB_File', $filename, O_CREAT|O_RDWR, 0666];
+
+  # Set up expiration policy, supplying persistent hash as a target
+  tie my %cache => 'Memoize::Expire', 
+	  	     LIFETIME => $lifetime,    # In seconds
+		     NUM_USES => $n_uses,
+                     HASH => \%disk_cache; 
+
+  # Set up memoization, supplying expiring persistent hash for cache
+  memoize 'function', SCALAR_CACHE => [ HASH => \%cache ];
+
+=head1 INTERFACE
+
+There is nothing special about Memoize::Expire.  It is just an
+example.  If you don't like the policy that it implements, you are
+free to write your own expiration policy module that implements
+whatever policy you desire.  Here is how to do that.  Let us suppose
+that your module will be named MyExpirePolicy.
+
+Short summary: You need to create a package that defines four methods:
+
+=over 4
+
+=item 
+TIEHASH
+
+Construct and return cache object.
+
+=item 
+EXISTS
+
+Given a function argument, is the corresponding function value in the
+cache, and if so, is it fresh enough to use?
+
+=item
+FETCH
+
+Given a function argument, look up the corresponding function value in
+the cache and return it.
+
+=item 
+STORE
+
+Given a function argument and the corresponding function value, store
+them into the cache.
+
+=item
+CLEAR
+
+(Optional.)  Flush the cache completely.
+
+=back
+
+The user who wants the memoization cache to be expired according to
+your policy will say so by writing
+
+  tie my %cache => 'MyExpirePolicy', args...;
+  memoize 'function', SCALAR_CACHE => [HASH => \%cache];
+
+This will invoke C<< MyExpirePolicy->TIEHASH(args) >>.
+MyExpirePolicy::TIEHASH should do whatever is appropriate to set up
+the cache, and it should return the cache object to the caller.
+
+For example, MyExpirePolicy::TIEHASH might create an object that
+contains a regular Perl hash (which it will to store the cached
+values) and some extra information about the arguments and how old the
+data is and things like that. Let us call this object I<C<C>>.
+
+When Memoize needs to check to see if an entry is in the cache
+already, it will invoke C<< C->EXISTS(key) >>.  C<key> is the normalized
+function argument.  MyExpirePolicy::EXISTS should return 0 if the key
+is not in the cache, or if it has expired, and 1 if an unexpired value
+is in the cache.  It should I<not> return C<undef>, because there is a
+bug in some versions of Perl that will cause a spurious FETCH if the
+EXISTS method returns C<undef>.
+
+If your EXISTS function returns true, Memoize will try to fetch the
+cached value by invoking C<< C->FETCH(key) >>.  MyExpirePolicy::FETCH should
+return the cached value.  Otherwise, Memoize will call the memoized
+function to compute the appropriate value, and will store it into the
+cache by calling C<< C->STORE(key, value) >>.
+
+Here is a very brief example of a policy module that expires each
+cache item after ten seconds.
+
+	package Memoize::TenSecondExpire;
+
+	sub TIEHASH {
+	  my ($package, %args) = @_;
+          my $cache = $args{HASH} || {};
+	  bless $cache => $package;
+	}
+
+	sub EXISTS {
+	  my ($cache, $key) = @_;
+	  if (exists $cache->{$key} && 
+              $cache->{$key}{EXPIRE_TIME} > time) {
+	    return 1
+	  } else {
+	    return 0;  # Do NOT return undef here
+	  }
+	}
+
+	sub FETCH {
+	  my ($cache, $key) = @_;
+	  return $cache->{$key}{VALUE};
+	}
+
+	sub STORE {
+	  my ($cache, $key, $newvalue) = @_;
+	  $cache->{$key}{VALUE} = $newvalue;
+	  $cache->{$key}{EXPIRE_TIME} = time + 10;
+	}
+
+To use this expiration policy, the user would say
+
+	use Memoize;
+        tie my %cache10sec => 'Memoize::TenSecondExpire';
+	memoize 'function', SCALAR_CACHE => [HASH => \%cache10sec];
+
+Memoize would then call C<function> whenever a cached value was
+entirely absent or was older than ten seconds.
+
+You should always support a C<HASH> argument to C<TIEHASH> that ties
+the underlying cache so that the user can specify that the cache is
+also persistent or that it has some other interesting semantics.  The
+example above demonstrates how to do this, as does C<Memoize::Expire>.
+
+Another sample module, L<Memoize::Saves>, is available in a separate
+distribution on CPAN.  It implements a policy that allows you to
+specify that certain function values would always be looked up afresh.
+See the documentation for details.
+
+=head1 ALTERNATIVES
+
+Brent Powers has a L<Memoize::ExpireLRU> module that was designed to
+work with Memoize and provides expiration of least-recently-used data.
+The cache is held at a fixed number of entries, and when new data
+comes in, the least-recently used data is expired.
+
+Joshua Chamas's Tie::Cache module may be useful as an expiration
+manager.  (If you try this, let me know how it works out.)
+
+If you develop any useful expiration managers that you think should be
+distributed with Memoize, please let me know.
+
+=head1 CAVEATS
+
+This module is experimental, and may contain bugs.  Please report bugs
+to the address below.
+
+Number-of-uses is stored as a 16-bit unsigned integer, so can't exceed
+65535.
+
+Because of clock granularity, expiration times may occur up to one
+second sooner than you expect.  For example, suppose you store a value
+with a lifetime of ten seconds, and you store it at 12:00:00.998 on a
+certain day.  Memoize will look at the clock and see 12:00:00.  Then
+9.01 seconds later, at 12:00:10.008 you try to read it back.  Memoize
+will look at the clock and see 12:00:10 and conclude that the value
+has expired.  This will probably not occur if you have
+C<Time::HiRes> installed.
+
+=head1 AUTHOR
+
+Mark-Jason Dominus
+
+Mike Cariaso provided valuable insight into the best way to solve this
+problem.
+
+=head1 SEE ALSO
+
+perl(1)
+
+The Memoize man page.
+
+=cut

git/usr/share/perl5/core_perl/Memoize/NDBM_File.pm

@@ -0,0 +1,39 @@
+use strict; use warnings;
+
+package Memoize::NDBM_File;
+our $VERSION = '1.17';
+
+use NDBM_File;
+our @ISA = qw(NDBM_File);
+
+# NDBM_File cannot store undef and will store an empty string if you try
+# but it does return undef if you try to read a non-existent key
+# so we can emulate exists() using defined()
+sub EXISTS {
+	defined shift->FETCH(@_);
+}
+
+# Perl 5.37.3 adds this EXISTS emulation to NDBM_File itself
+delete $Memoize::NDBM_File::{'EXISTS'}
+	if eval { NDBM_File->VERSION( '1.16' ) };
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Memoize::NDBM_File - glue to provide EXISTS for NDBM_File for Storable use
+
+=head1 DESCRIPTION
+
+This class provides L<EXISTS|perltie/C<EXISTS>> support for L<NDBM_File>.
+
+L<In Perl 5.37.3|https://github.com/Perl/perl5/commit/c0a1a377c02ed789f5eff667f46a2314a05c5a4c>,
+support for C<EXISTS> was added to L<NDBM_File> itself.
+Any code which already requires perl >= 5.37.3 should be rewritten to use
+L<NDBM_File> directly.
+
+=cut

git/usr/share/perl5/core_perl/Memoize/SDBM_File.pm

@@ -0,0 +1,27 @@
+use strict; use warnings;
+
+package Memoize::SDBM_File;
+our $VERSION = '1.17';
+
+use SDBM_File 1.01; # for EXISTS support
+our @ISA = qw(SDBM_File);
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Memoize::SDBM_File - DEPRECATED compatibility shim
+
+=head1 DESCRIPTION
+
+This class used to provide L<EXISTS|perltie/C<EXISTS>> support for L<SDBM_File>
+before support for C<EXISTS> was added to L<SDBM_File> itself
+L<in Perl 5.6.0|perl56delta/SDBM_File>.
+
+Any code still using this class should be rewritten to use L<SDBM_File> directly.
+
+=cut

git/usr/share/perl5/core_perl/Memoize/Storable.pm

@@ -0,0 +1,75 @@
+use strict; use warnings;
+
+package Memoize::Storable;
+our $VERSION = '1.17';
+
+use Storable 1.002 (); # for lock_* function variants
+
+our $Verbose;
+
+sub TIEHASH {
+  my $package = shift;
+  my $filename = shift;
+  my $truehash = (-e $filename) ? Storable::lock_retrieve($filename) : {};
+  my %options;
+  print STDERR "Memoize::Storable::TIEHASH($filename, @_)\n" if $Verbose;
+  @options{@_} = (1) x @_;
+  my $self = 
+    {FILENAME => $filename, 
+     H => $truehash, 
+     OPTIONS => \%options
+    };
+  bless $self => $package;
+}
+
+sub STORE {
+  my $self = shift;
+  print STDERR "Memoize::Storable::STORE(@_)\n" if $Verbose;
+  $self->{H}{$_[0]} = $_[1];
+}
+
+sub FETCH {
+  my $self = shift;
+  print STDERR "Memoize::Storable::FETCH(@_)\n" if $Verbose;
+  $self->{H}{$_[0]};
+}
+
+sub EXISTS {
+  my $self = shift;
+  print STDERR "Memoize::Storable::EXISTS(@_)\n" if $Verbose;
+  exists $self->{H}{$_[0]};
+}
+
+sub DESTROY {
+  my $self= shift;
+  print STDERR "Memoize::Storable::DESTROY(@_)\n" if $Verbose;
+  if ($self->{OPTIONS}{'nstore'}) {
+    Storable::lock_nstore($self->{H}, $self->{FILENAME});
+  } else {
+    Storable::lock_store($self->{H}, $self->{FILENAME});
+  }
+}
+
+sub FIRSTKEY {
+  'Fake hash from Memoize::Storable';
+}
+
+sub NEXTKEY {
+  undef;
+}
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Memoize::Storable - store Memoized data in Storable database
+
+=head1 DESCRIPTION
+
+See L<Memoize>.
+
+=cut

git/usr/share/perl5/core_perl/Module/Load.pm

@@ -0,0 +1,373 @@
+package Module::Load;
+
+use strict;
+use warnings;
+use File::Spec ();
+
+our $VERSION = '0.36';
+
+
+sub import {
+    my $who = _who();
+    my $h; shift;
+
+    {   no strict 'refs';
+
+        @_ or (
+            *{"${who}::load"} = \&load, # compat to prev version
+            *{"${who}::autoload"} = \&autoload,
+            return
+        );
+
+        map { $h->{$_} = () if defined $_ } @_;
+
+        (exists $h->{none} or exists $h->{''})
+            and shift, last;
+
+        ((exists $h->{autoload} and shift,1) or (exists $h->{all} and shift))
+            and *{"${who}::autoload"} = \&autoload;
+
+        ((exists $h->{load} and shift,1) or exists $h->{all})
+            and *{"${who}::load"} = \&load;
+
+        ((exists $h->{load_remote} and shift,1) or exists $h->{all})
+            and *{"${who}::load_remote"} = \&load_remote;
+
+        ((exists $h->{autoload_remote} and shift,1) or exists $h->{all})
+            and *{"${who}::autoload_remote"} = \&autoload_remote;
+
+    }
+
+}
+
+sub load(*;@){
+    goto &_load;
+}
+
+sub autoload(*;@){
+    unshift @_, 'autoimport';
+    goto &_load;
+}
+
+sub load_remote($$;@){
+    my ($dst, $src, @exp) = @_;
+
+    eval "package $dst;Module::Load::load('$src', qw/@exp/);";
+    $@ && die "$@";
+}
+
+sub autoload_remote($$;@){
+    my ($dst, $src, @exp) = @_;
+
+    eval "package $dst;Module::Load::autoload('$src', qw/@exp/);";
+    $@ && die "$@";
+}
+
+sub _load{
+    my $autoimport = $_[0] eq 'autoimport' and shift;
+    my $mod = shift or return;
+    my $who = _who();
+
+    if( _is_file( $mod ) ) {
+        require $mod;
+    } else {
+        LOAD: {
+            my $err;
+            for my $flag ( qw[1 0] ) {
+                my $file = _to_file( $mod, $flag);
+                eval { require $file };
+                $@ ? $err .= $@ : last LOAD;
+            }
+            die $err if $err;
+        }
+    }
+
+    ### This addresses #41883: Module::Load cannot import
+    ### non-Exporter module. ->import() routines weren't
+    ### properly called when load() was used.
+
+    {   no strict 'refs';
+        my $import;
+
+    ((@_ or $autoimport) and (
+        $import = $mod->can('import')
+        ) and (
+        unshift(@_, $mod),
+        goto &$import
+        )
+    );
+    }
+
+}
+
+sub _to_file{
+    local $_    = shift;
+    my $pm      = shift || '';
+
+    ## trailing blanks ignored by default. [rt #69886]
+    my @parts = split /::|'/, $_, -1;
+    ## make sure that we can't hop out of @INC
+    shift @parts if @parts && !$parts[0];
+
+    ### because of [perl #19213], see caveats ###
+    my $file = $^O eq 'MSWin32'
+                    ? join "/", @parts
+                    : File::Spec->catfile( @parts );
+
+    $file   .= '.pm' if $pm;
+
+    ### on perl's before 5.10 (5.9.5@31746) if you require
+    ### a file in VMS format, it's stored in %INC in VMS
+    ### format. Therefor, better unixify it first
+    ### Patch in reply to John Malmbergs patch (as mentioned
+    ### above) on p5p Tue 21 Aug 2007 04:55:07
+    $file = VMS::Filespec::unixify($file) if $^O eq 'VMS';
+
+    return $file;
+}
+
+sub _who { (caller(1))[0] }
+
+sub _is_file {
+    local $_ = shift;
+    return  /^\./               ? 1 :
+            /[^\w:']/           ? 1 :
+            undef
+    #' silly bbedit..
+}
+
+
+1;
+
+__END__
+
+=pod
+
+=head1 NAME
+
+Module::Load - runtime require of both modules and files
+
+=head1 SYNOPSIS
+
+  use Module::Load;
+
+  my $module = 'Data::Dumper';
+
+  load Data::Dumper;     # loads that module, but not import any functions
+                         # -> cannot use 'Dumper' function
+
+  load 'Data::Dumper';   # ditto
+  load $module           # tritto
+
+  autoload Data::Dumper; # loads that module and imports the default functions
+                         # -> can use 'Dumper' function
+
+  my $script = 'some/script.pl'
+  load $script;
+  load 'some/script.pl';  # use quotes because of punctuations
+
+  load thing;             # try 'thing' first, then 'thing.pm'
+
+  load CGI, ':all';       # like 'use CGI qw[:standard]'
+
+=head1 DESCRIPTION
+
+C<Module::Load> eliminates the need to know whether you are trying
+to require either a file or a module.
+
+If you consult C<perldoc -f require> you will see that C<require> will
+behave differently when given a bareword or a string.
+
+In the case of a string, C<require> assumes you are wanting to load a
+file. But in the case of a bareword, it assumes you mean a module.
+
+This gives nasty overhead when you are trying to dynamically require
+modules at runtime, since you will need to change the module notation
+(C<Acme::Comment>) to a file notation fitting the particular platform
+you are on.
+
+C<Module::Load> eliminates the need for this overhead and will
+just DWYM.
+
+=head2 Difference between C<load> and C<autoload>
+
+C<Module::Load> imports the two functions - C<load> and C<autoload>
+
+C<autoload> imports the default functions automatically,
+but C<load> do not import any functions.
+
+C<autoload> is usable under C<BEGIN{};>.
+
+Both the functions can import the functions that are specified.
+
+Following codes are same.
+
+  load File::Spec::Functions, qw/splitpath/;
+
+  autoload File::Spec::Functions, qw/splitpath/;
+
+=head1 FUNCTIONS
+
+=over 4
+
+=item load
+
+Loads a specified module.
+
+See L</Rules> for detailed loading rule.
+
+=item autoload
+
+Loads a specified module and imports the default functions.
+
+Except importing the functions, 'autoload' is same as 'load'.
+
+=item load_remote
+
+Loads a specified module to the specified package.
+
+  use Module::Load 'load_remote';
+
+  my $pkg = 'Other::Package';
+
+  load_remote $pkg, 'Data::Dumper'; # load a module to 'Other::Package'
+                                    # but do not import 'Dumper' function
+
+A module for loading must be quoted.
+
+Except specifing the package and quoting module name,
+'load_remote' is same as 'load'.
+
+=item autoload_remote
+
+Loads a specified module and imports the default functions to the specified package.
+
+  use Module::Load 'autoload_remote';
+
+  my $pkg = 'Other::Package';
+
+  autoload_remote $pkg, 'Data::Dumper'; # load a module to 'Other::Package'
+                                        # and imports 'Dumper' function
+
+A module for loading must be quoted.
+
+Except specifing the package and quoting module name,
+'autoload_remote' is same as 'load_remote'.
+
+=back
+
+=head1 Rules
+
+All functions have the following rules to decide what it thinks
+you want:
+
+=over 4
+
+=item *
+
+If the argument has any characters in it other than those matching
+C<\w>, C<:> or C<'>, it must be a file
+
+=item *
+
+If the argument matches only C<[\w:']>, it must be a module
+
+=item *
+
+If the argument matches only C<\w>, it could either be a module or a
+file. We will try to find C<file.pm> first in C<@INC> and if that
+fails, we will try to find C<file> in @INC.  If both fail, we die with
+the respective error messages.
+
+=back
+
+=head1 IMPORTS THE FUNCTIONS
+
+'load' and 'autoload' are imported by default, but 'load_remote' and
+'autoload_remote' are not imported.
+
+To use 'load_remote' or 'autoload_remote', specify at 'use'.
+
+=over 4
+
+=item "load","autoload","load_remote","autoload_remote"
+
+Imports the selected functions.
+
+  # imports 'load' and 'autoload' (default)
+  use Module::Load;
+
+  # imports 'autoload' only
+  use Module::Load 'autoload';
+
+  # imports 'autoload' and 'autoload_remote', but don't import 'load';
+  use Module::Load qw/autoload autoload_remote/;
+
+=item 'all'
+
+Imports all the functions.
+
+  use Module::Load 'all'; # imports load, autoload, load_remote, autoload_remote
+
+=item '','none',undef
+
+Not import any functions (C<load> and C<autoload> are not imported).
+
+  use Module::Load '';
+
+  use Module::Load 'none';
+
+  use Module::Load undef;
+
+=back
+
+=head1 Caveats
+
+Because of a bug in perl (#19213), at least in version 5.6.1, we have
+to hardcode the path separator for a require on Win32 to be C</>, like
+on Unix rather than the Win32 C<\>. Otherwise perl will not read its
+own %INC accurately double load files if they are required again, or
+in the worst case, core dump.
+
+C<Module::Load> cannot do implicit imports, only explicit imports.
+(in other words, you always have to specify explicitly what you wish
+to import from a module, even if the functions are in that modules'
+C<@EXPORT>)
+
+=head1 SEE ALSO
+
+L<Module::Runtime> provides functions for loading modules,
+checking the validity of a module name,
+converting a module name to partial C<.pm> path,
+and related utility functions.
+
+L<"require" in perlfunc|https://metacpan.org/pod/perlfunc#require>
+and
+L<"use" in perlfunc|https://metacpan.org/pod/perlfunc#use>.
+
+L<Mojo::Loader> is a "class loader and plugin framework",
+and is included in the
+L<Mojolicious|https://metacpan.org/release/Mojolicious> distribution.
+
+L<Module::Loader> is a module for finding and loading modules
+in a given namespace, inspired by C<Mojo::Loader>.
+
+
+=head1 ACKNOWLEDGEMENTS
+
+Thanks to Jonas B. Nielsen for making explicit imports work.
+
+=head1 BUG REPORTS
+
+Please report bugs or other issues to E<lt>bug-module-load@rt.cpan.orgE<gt>.
+
+=head1 AUTHOR
+
+This module by Jos Boumans E<lt>kane@cpan.orgE<gt>.
+
+=head1 COPYRIGHT
+
+This library is free software; you may redistribute and/or modify it
+under the same terms as Perl itself.
+
+=cut

git/usr/share/perl5/core_perl/Module/Loaded.pm

@@ -0,0 +1,142 @@
+package Module::Loaded;
+
+use strict;
+use Carp qw[carp];
+
+BEGIN { use base 'Exporter';
+        use vars qw[@EXPORT $VERSION];
+
+        $VERSION = '0.08';
+        @EXPORT  = qw[mark_as_loaded mark_as_unloaded is_loaded];
+}
+
+=head1 NAME
+
+Module::Loaded - mark modules as loaded or unloaded
+
+=head1 SYNOPSIS
+
+    use Module::Loaded;
+
+    $bool = mark_as_loaded('Foo');   # Foo.pm is now marked as loaded
+    $loc  = is_loaded('Foo');        # location of Foo.pm set to the
+                                     # loaders location
+    eval "require 'Foo'";            # is now a no-op
+
+    $bool = mark_as_unloaded('Foo'); # Foo.pm no longer marked as loaded
+    eval "require 'Foo'";            # Will try to find Foo.pm in @INC
+
+=head1 DESCRIPTION
+
+When testing applications, often you find yourself needing to provide
+functionality in your test environment that would usually be provided
+by external modules. Rather than munging the C<%INC> by hand to mark
+these external modules as loaded, so they are not attempted to be loaded
+by perl, this module offers you a very simple way to mark modules as
+loaded and/or unloaded.
+
+=head1 FUNCTIONS
+
+=head2 $bool = mark_as_loaded( PACKAGE );
+
+Marks the package as loaded to perl. C<PACKAGE> can be a bareword or
+string.
+
+If the module is already loaded, C<mark_as_loaded> will carp about
+this and tell you from where the C<PACKAGE> has been loaded already.
+
+=cut
+
+sub mark_as_loaded (*) {
+    my $pm      = shift;
+    my $file    = __PACKAGE__->_pm_to_file( $pm ) or return;
+    my $who     = [caller]->[1];
+
+    my $where   = is_loaded( $pm );
+    if ( defined $where ) {
+        carp "'$pm' already marked as loaded ('$where')";
+
+    } else {
+        $INC{$file} = $who;
+    }
+
+    return 1;
+}
+
+=head2 $bool = mark_as_unloaded( PACKAGE );
+
+Marks the package as unloaded to perl, which is the exact opposite
+of C<mark_as_loaded>. C<PACKAGE> can be a bareword or string.
+
+If the module is already unloaded, C<mark_as_unloaded> will carp about
+this and tell you the C<PACKAGE> has been unloaded already.
+
+=cut
+
+sub mark_as_unloaded (*) {
+    my $pm      = shift;
+    my $file    = __PACKAGE__->_pm_to_file( $pm ) or return;
+
+    unless( defined is_loaded( $pm ) ) {
+        carp "'$pm' already marked as unloaded";
+
+    } else {
+        delete $INC{ $file };
+    }
+
+    return 1;
+}
+
+=head2 $loc = is_loaded( PACKAGE );
+
+C<is_loaded> tells you if C<PACKAGE> has been marked as loaded yet.
+C<PACKAGE> can be a bareword or string.
+
+It returns falls if C<PACKAGE> has not been loaded yet and the location
+from where it is said to be loaded on success.
+
+=cut
+
+sub is_loaded (*) {
+    my $pm      = shift;
+    my $file    = __PACKAGE__->_pm_to_file( $pm ) or return;
+
+    return $INC{$file} if exists $INC{$file};
+
+    return;
+}
+
+
+sub _pm_to_file {
+    my $pkg = shift;
+    my $pm  = shift or return;
+
+    my $file = join '/', split '::', $pm;
+    $file .= '.pm';
+
+    return $file;
+}
+
+=head1 BUG REPORTS
+
+Please report bugs or other issues to E<lt>bug-module-loaded@rt.cpan.org<gt>.
+
+=head1 AUTHOR
+
+This module by Jos Boumans E<lt>kane@cpan.orgE<gt>.
+
+=head1 COPYRIGHT
+
+This library is free software; you may redistribute and/or modify it
+under the same terms as Perl itself.
+
+=cut
+
+# Local variables:
+# c-indentation-style: bsd
+# c-basic-offset: 4
+# indent-tabs-mode: nil
+# End:
+# vim: expandtab shiftwidth=4:
+
+1;

git/usr/share/perl5/core_perl/Module/Metadata.pm

@@ -0,0 +1,1207 @@
+# -*- mode: cperl; tab-width: 8; indent-tabs-mode: nil; basic-offset: 2 -*-
+# vim:ts=8:sw=2:et:sta:sts=2:tw=78
+package Module::Metadata; # git description: v1.000037-8-g92dec6c
+# ABSTRACT: Gather package and POD information from perl module files
+
+# Adapted from Perl-licensed code originally distributed with
+# Module-Build by Ken Williams
+
+# This module provides routines to gather information about
+# perl modules (assuming this may be expanded in the distant
+# parrot future to look at other types of modules).
+
+sub __clean_eval { eval $_[0] }
+use strict;
+use warnings;
+
+our $VERSION = '1.000038';
+
+use Carp qw/croak/;
+use File::Spec;
+BEGIN {
+       # Try really hard to not depend ony any DynaLoaded module, such as IO::File or Fcntl
+       eval {
+               require Fcntl; Fcntl->import('SEEK_SET'); 1;
+       } or *SEEK_SET = sub { 0 }
+}
+use version 0.87;
+BEGIN {
+  if ($INC{'Log/Contextual.pm'}) {
+    require "Log/Contextual/WarnLogger.pm"; # Hide from AutoPrereqs
+    Log::Contextual->import('log_info',
+      '-default_logger' => Log::Contextual::WarnLogger->new({ env_prefix => 'MODULE_METADATA', }),
+    );
+  }
+  else {
+    *log_info = sub (&) { warn $_[0]->() };
+  }
+}
+use File::Find qw(find);
+
+my $V_NUM_REGEXP = qr{v?[0-9._]+};  # crudely, a v-string or decimal
+
+my $PKG_FIRST_WORD_REGEXP = qr{ # the FIRST word in a package name
+  [a-zA-Z_]                     # the first word CANNOT start with a digit
+    (?:
+      [\w']?                    # can contain letters, digits, _, or ticks
+      \w                        # But, NO multi-ticks or trailing ticks
+    )*
+}x;
+
+my $PKG_ADDL_WORD_REGEXP = qr{ # the 2nd+ word in a package name
+  \w                           # the 2nd+ word CAN start with digits
+    (?:
+      [\w']?                   # and can contain letters or ticks
+      \w                       # But, NO multi-ticks or trailing ticks
+    )*
+}x;
+
+my $PKG_NAME_REGEXP = qr{ # match a package name
+  (?: :: )?               # a pkg name can start with arisdottle
+  $PKG_FIRST_WORD_REGEXP  # a package word
+  (?:
+    (?: :: )+             ### arisdottle (allow one or many times)
+    $PKG_ADDL_WORD_REGEXP ### a package word
+  )*                      # ^ zero, one or many times
+  (?:
+    ::                    # allow trailing arisdottle
+  )?
+}x;
+
+my $PKG_REGEXP  = qr{   # match a package declaration
+  ^[\s\{;]*             # intro chars on a line
+  package               # the word 'package'
+  \s+                   # whitespace
+  ($PKG_NAME_REGEXP)    # a package name
+  \s*                   # optional whitespace
+  ($V_NUM_REGEXP)?      # optional version number
+  \s*                   # optional whitespace
+  [;\{]                 # semicolon line terminator or block start (since 5.16)
+}x;
+
+my $CLASS_REGEXP = qr{  # match a class declaration (core since 5.38)
+  ^[\s\{;]*             # intro chars on a line
+  class                 # the word 'class'
+  \s+                   # whitespace
+  ($PKG_NAME_REGEXP)    # a package name
+  \s*                   # optional whitespace
+  ($V_NUM_REGEXP)?      # optional version number
+  \s*                   # optional whitespace
+  [;\{]                 # semicolon line terminator or block start
+}x;
+
+my $VARNAME_REGEXP = qr{ # match fully-qualified VERSION name
+  ([\$*])         # sigil - $ or *
+  (
+    (             # optional leading package name
+      (?:::|\')?  # possibly starting like just :: (a la $::VERSION)
+      (?:\w+(?:::|\'))*  # Foo::Bar:: ...
+    )?
+    VERSION
+  )\b
+}x;
+
+my $VERS_REGEXP = qr{ # match a VERSION definition
+  (?:
+    \(\s*$VARNAME_REGEXP\s*\) # with parens
+  |
+    $VARNAME_REGEXP           # without parens
+  )
+  \s*
+  =[^=~>]  # = but not ==, nor =~, nor =>
+}x;
+
+sub new_from_file {
+  my $class    = shift;
+  my $filename = File::Spec->rel2abs( shift );
+
+  return undef unless defined( $filename ) && -f $filename;
+  return $class->_init(undef, $filename, @_);
+}
+
+sub new_from_handle {
+  my $class    = shift;
+  my $handle   = shift;
+  my $filename = shift;
+  return undef unless defined($handle) && defined($filename);
+  $filename = File::Spec->rel2abs( $filename );
+
+  return $class->_init(undef, $filename, @_, handle => $handle);
+
+}
+
+
+sub new_from_module {
+  my $class   = shift;
+  my $module  = shift;
+  my %props   = @_;
+
+  $props{inc} ||= \@INC;
+  my $filename = $class->find_module_by_name( $module, $props{inc} );
+  return undef unless defined( $filename ) && -f $filename;
+  return $class->_init($module, $filename, %props);
+}
+
+{
+
+  my $compare_versions = sub {
+    my ($v1, $op, $v2) = @_;
+    $v1 = version->new($v1)
+      unless UNIVERSAL::isa($v1,'version');
+
+    my $eval_str = "\$v1 $op \$v2";
+    my $result   = eval $eval_str;
+    log_info { "error comparing versions: '$eval_str' $@" } if $@;
+
+    return $result;
+  };
+
+  my $normalize_version = sub {
+    my ($version) = @_;
+    if ( $version =~ /[=<>!,]/ ) { # logic, not just version
+      # take as is without modification
+    }
+    elsif ( ref $version eq 'version' ) { # version objects
+      $version = $version->is_qv ? $version->normal : $version->stringify;
+    }
+    elsif ( $version =~ /^[^v][^.]*\.[^.]+\./ ) { # no leading v, multiple dots
+      # normalize string tuples without "v": "1.2.3" -> "v1.2.3"
+      $version = "v$version";
+    }
+    else {
+      # leave alone
+    }
+    return $version;
+  };
+
+  # separate out some of the conflict resolution logic
+
+  my $resolve_module_versions = sub {
+    my $packages = shift;
+
+    my( $file, $version );
+    my $err = '';
+      foreach my $p ( @$packages ) {
+        if ( defined( $p->{version} ) ) {
+          if ( defined( $version ) ) {
+            if ( $compare_versions->( $version, '!=', $p->{version} ) ) {
+              $err .= "  $p->{file} ($p->{version})\n";
+            }
+            else {
+              # same version declared multiple times, ignore
+            }
+          }
+          else {
+            $file    = $p->{file};
+            $version = $p->{version};
+          }
+        }
+      $file ||= $p->{file} if defined( $p->{file} );
+    }
+
+    if ( $err ) {
+      $err = "  $file ($version)\n" . $err;
+    }
+
+    my %result = (
+      file    => $file,
+      version => $version,
+      err     => $err
+    );
+
+    return \%result;
+  };
+
+  sub provides {
+    my $class = shift;
+
+    croak "provides() requires key/value pairs \n" if @_ % 2;
+    my %args = @_;
+
+    croak "provides() takes only one of 'dir' or 'files'\n"
+      if $args{dir} && $args{files};
+
+    croak "provides() requires a 'version' argument"
+      unless defined $args{version};
+
+    croak "provides() does not support version '$args{version}' metadata"
+        unless grep $args{version} eq $_, qw/1.4 2/;
+
+    $args{prefix} = 'lib' unless defined $args{prefix};
+
+    my $p;
+    if ( $args{dir} ) {
+      $p = $class->package_versions_from_directory($args{dir});
+    }
+    else {
+      croak "provides() requires 'files' to be an array reference\n"
+        unless ref $args{files} eq 'ARRAY';
+      $p = $class->package_versions_from_directory($args{files});
+    }
+
+    # Now, fix up files with prefix
+    if ( length $args{prefix} ) { # check in case disabled with q{}
+      $args{prefix} =~ s{/$}{};
+      for my $v ( values %$p ) {
+        $v->{file} = "$args{prefix}/$v->{file}";
+      }
+    }
+
+    return $p
+  }
+
+  sub package_versions_from_directory {
+    my ( $class, $dir, $files ) = @_;
+
+    my @files;
+
+    if ( $files ) {
+      @files = @$files;
+    }
+    else {
+      find( {
+        wanted => sub {
+          push @files, $_ if -f $_ && /\.pm$/;
+        },
+        no_chdir => 1,
+      }, $dir );
+    }
+
+    # First, we enumerate all packages & versions,
+    # separating into primary & alternative candidates
+    my( %prime, %alt );
+    foreach my $file (@files) {
+      my $mapped_filename = File::Spec->abs2rel( $file, $dir );
+      my @path = File::Spec->splitdir( $mapped_filename );
+      (my $prime_package = join( '::', @path )) =~ s/\.pm$//;
+
+      my $pm_info = $class->new_from_file( $file );
+
+      foreach my $package ( $pm_info->packages_inside ) {
+        next if $package eq 'main';  # main can appear numerous times, ignore
+        next if $package eq 'DB';    # special debugging package, ignore
+        next if grep /^_/, split( /::/, $package ); # private package, ignore
+
+        my $version = $pm_info->version( $package );
+
+        $prime_package = $package if lc($prime_package) eq lc($package);
+        if ( $package eq $prime_package ) {
+          if ( exists( $prime{$package} ) ) {
+            croak "Unexpected conflict in '$package'; multiple versions found.\n";
+          }
+          else {
+            $mapped_filename = "$package.pm" if lc("$package.pm") eq lc($mapped_filename);
+            $prime{$package}{file} = $mapped_filename;
+            $prime{$package}{version} = $version if defined( $version );
+          }
+        }
+        else {
+          push( @{$alt{$package}}, {
+                                    file    => $mapped_filename,
+                                    version => $version,
+                                   } );
+        }
+      }
+    }
+
+    # Then we iterate over all the packages found above, identifying conflicts
+    # and selecting the "best" candidate for recording the file & version
+    # for each package.
+    foreach my $package ( keys( %alt ) ) {
+      my $result = $resolve_module_versions->( $alt{$package} );
+
+      if ( exists( $prime{$package} ) ) { # primary package selected
+
+        if ( $result->{err} ) {
+        # Use the selected primary package, but there are conflicting
+        # errors among multiple alternative packages that need to be
+        # reported
+          log_info {
+            "Found conflicting versions for package '$package'\n" .
+            "  $prime{$package}{file} ($prime{$package}{version})\n" .
+            $result->{err}
+          };
+
+        }
+        elsif ( defined( $result->{version} ) ) {
+        # There is a primary package selected, and exactly one
+        # alternative package
+
+        if ( exists( $prime{$package}{version} ) &&
+             defined( $prime{$package}{version} ) ) {
+          # Unless the version of the primary package agrees with the
+          # version of the alternative package, report a conflict
+        if ( $compare_versions->(
+                 $prime{$package}{version}, '!=', $result->{version}
+               )
+             ) {
+
+            log_info {
+              "Found conflicting versions for package '$package'\n" .
+              "  $prime{$package}{file} ($prime{$package}{version})\n" .
+              "  $result->{file} ($result->{version})\n"
+            };
+          }
+
+        }
+        else {
+          # The prime package selected has no version so, we choose to
+          # use any alternative package that does have a version
+          $prime{$package}{file}    = $result->{file};
+          $prime{$package}{version} = $result->{version};
+        }
+
+        }
+        else {
+        # no alt package found with a version, but we have a prime
+        # package so we use it whether it has a version or not
+        }
+
+      }
+      else { # No primary package was selected, use the best alternative
+
+        if ( $result->{err} ) {
+          log_info {
+            "Found conflicting versions for package '$package'\n" .
+            $result->{err}
+          };
+        }
+
+        # Despite possible conflicting versions, we choose to record
+        # something rather than nothing
+        $prime{$package}{file}    = $result->{file};
+        $prime{$package}{version} = $result->{version}
+          if defined( $result->{version} );
+      }
+    }
+
+    # Normalize versions.  Can't use exists() here because of bug in YAML::Node.
+    # XXX "bug in YAML::Node" comment seems irrelevant -- dagolden, 2009-05-18
+    for (grep defined $_->{version}, values %prime) {
+      $_->{version} = $normalize_version->( $_->{version} );
+    }
+
+    return \%prime;
+  }
+}
+
+
+sub _init {
+  my $class    = shift;
+  my $module   = shift;
+  my $filename = shift;
+  my %props = @_;
+
+  my $handle = delete $props{handle};
+  my( %valid_props, @valid_props );
+  @valid_props = qw( collect_pod inc decode_pod );
+  @valid_props{@valid_props} = delete( @props{@valid_props} );
+  warn "Unknown properties: @{[keys %props]}\n" if scalar( %props );
+
+  my %data = (
+    module       => $module,
+    filename     => $filename,
+    version      => undef,
+    packages     => [],
+    versions     => {},
+    pod          => {},
+    pod_headings => [],
+    collect_pod  => 0,
+
+    %valid_props,
+  );
+
+  my $self = bless(\%data, $class);
+
+  if ( not $handle ) {
+    my $filename = $self->{filename};
+    open $handle, '<', $filename
+      or croak( "Can't open '$filename': $!" );
+
+    $self->_handle_bom($handle, $filename);
+  }
+  $self->_parse_fh($handle);
+
+  @{$self->{packages}} = __uniq(@{$self->{packages}});
+
+  unless($self->{module} and length($self->{module})) {
+    # CAVEAT (possible TODO): .pmc files not treated the same as .pm
+    if ($self->{filename} =~ /\.pm$/) {
+      my ($v, $d, $f) = File::Spec->splitpath($self->{filename});
+      $f =~ s/\..+$//;
+      my @candidates = grep /(^|::)$f$/, @{$self->{packages}};
+      $self->{module} = shift(@candidates); # this may be undef
+    }
+    else {
+      # this seems like an atrocious heuristic, albeit marginally better than
+      # what was here before. It should be rewritten entirely to be more like
+      # "if it's not a .pm file, it's not require()able as a name, therefore
+      # name() should be undef."
+      if ((grep /main/, @{$self->{packages}})
+          or (grep /main/, keys %{$self->{versions}})) {
+        $self->{module} = 'main';
+      }
+      else {
+        # TODO: this should maybe default to undef instead
+        $self->{module} = $self->{packages}[0] || '';
+      }
+    }
+  }
+
+  $self->{version} = $self->{versions}{$self->{module}}
+    if defined( $self->{module} );
+
+  return $self;
+}
+
+# class method
+sub _do_find_module {
+  my $class   = shift;
+  my $module  = shift || croak 'find_module_by_name() requires a package name';
+  my $dirs    = shift || \@INC;
+
+  my $file = File::Spec->catfile(split( /::/, $module));
+  foreach my $dir ( @$dirs ) {
+    my $testfile = File::Spec->catfile($dir, $file);
+    return [ File::Spec->rel2abs( $testfile ), $dir ]
+      if -e $testfile and !-d _;  # For stuff like ExtUtils::xsubpp
+    # CAVEAT (possible TODO): .pmc files are not discoverable here
+    $testfile .= '.pm';
+    return [ File::Spec->rel2abs( $testfile ), $dir ]
+      if -e $testfile;
+  }
+  return;
+}
+
+# class method
+sub find_module_by_name {
+  my $found = shift()->_do_find_module(@_) or return;
+  return $found->[0];
+}
+
+# class method
+sub find_module_dir_by_name {
+  my $found = shift()->_do_find_module(@_) or return;
+  return $found->[1];
+}
+
+
+# given a line of perl code, attempt to parse it if it looks like a
+# $VERSION assignment, returning sigil, full name, & package name
+sub _parse_version_expression {
+  my $self = shift;
+  my $line = shift;
+
+  my( $sigil, $variable_name, $package);
+  if ( $line =~ /$VERS_REGEXP/o ) {
+    ( $sigil, $variable_name, $package) = $2 ? ( $1, $2, $3 ) : ( $4, $5, $6 );
+    if ( $package ) {
+      $package = ($package eq '::') ? 'main' : $package;
+      $package =~ s/::$//;
+    }
+  }
+
+  return ( $sigil, $variable_name, $package );
+}
+
+# Look for a UTF-8/UTF-16BE/UTF-16LE BOM at the beginning of the stream.
+# If there's one, then skip it and set the :encoding layer appropriately.
+sub _handle_bom {
+  my ($self, $fh, $filename) = @_;
+
+  my $pos = tell $fh;
+  return unless defined $pos;
+
+  my $buf = ' ' x 2;
+  my $count = read $fh, $buf, length $buf;
+  return unless defined $count and $count >= 2;
+
+  my $encoding;
+  if ( $buf eq "\x{FE}\x{FF}" ) {
+    $encoding = 'UTF-16BE';
+  }
+  elsif ( $buf eq "\x{FF}\x{FE}" ) {
+    $encoding = 'UTF-16LE';
+  }
+  elsif ( $buf eq "\x{EF}\x{BB}" ) {
+    $buf = ' ';
+    $count = read $fh, $buf, length $buf;
+    if ( defined $count and $count >= 1 and $buf eq "\x{BF}" ) {
+      $encoding = 'UTF-8';
+    }
+  }
+
+  if ( defined $encoding ) {
+    if ( "$]" >= 5.008 ) {
+      binmode( $fh, ":encoding($encoding)" );
+    }
+  }
+  else {
+    seek $fh, $pos, SEEK_SET
+      or croak( sprintf "Can't reset position to the top of '$filename'" );
+  }
+
+  return $encoding;
+}
+
+sub _parse_fh {
+  my ($self, $fh) = @_;
+
+  my( $in_pod, $seen_end, $need_vers ) = ( 0, 0, 0 );
+  my( @packages, %vers, %pod, @pod );
+  my $package = 'main';
+  my $pod_sect = '';
+  my $pod_data = '';
+  my $in_end = 0;
+  my $encoding = '';
+
+  while (defined( my $line = <$fh> )) {
+    my $line_num = $.;
+
+    chomp( $line );
+
+    # From toke.c : any line that begins by "=X", where X is an alphabetic
+    # character, introduces a POD segment.
+    my $is_cut;
+    if ( $line =~ /^=([a-zA-Z].*)/ ) {
+      my $cmd = $1;
+      # Then it goes back to Perl code for "=cutX" where X is a non-alphabetic
+      # character (which includes the newline, but here we chomped it away).
+      $is_cut = $cmd =~ /^cut(?:[^a-zA-Z]|$)/;
+      $in_pod = !$is_cut;
+    }
+
+    if ( $in_pod ) {
+
+      if ( $line =~ /^=head[1-4]\s+(.+)\s*$/ ) {
+        push( @pod, $1 );
+        if ( $self->{collect_pod} && length( $pod_data ) ) {
+          $pod{$pod_sect} = $pod_data;
+          $pod_data = '';
+        }
+        $pod_sect = $1;
+      }
+      elsif ( $self->{collect_pod} ) {
+        if ( $self->{decode_pod} && $line =~ /^=encoding ([\w-]+)/ ) {
+          $encoding = $1;
+        }
+        $pod_data .= "$line\n";
+      }
+      next;
+    }
+    elsif ( $is_cut ) {
+      if ( $self->{collect_pod} && length( $pod_data ) ) {
+        $pod{$pod_sect} = $pod_data;
+        $pod_data = '';
+      }
+      $pod_sect = '';
+      next;
+    }
+
+    # Skip after __END__
+    next if $in_end;
+
+    # Skip comments in code
+    next if $line =~ /^\s*#/;
+
+    # Would be nice if we could also check $in_string or something too
+    if ($line eq '__END__') {
+      $in_end++;
+      next;
+    }
+
+    last if $line eq '__DATA__';
+
+    # parse $line to see if it's a $VERSION declaration
+    my( $version_sigil, $version_fullname, $version_package ) =
+      index($line, 'VERSION') >= 1
+        ? $self->_parse_version_expression( $line )
+        : ();
+
+    if ( $line =~ /$PKG_REGEXP/o or $line =~ /$CLASS_REGEXP/ ) {
+      $package = $1;
+      my $version = $2;
+      push( @packages, $package ) unless grep( $package eq $_, @packages );
+      $need_vers = defined $version ? 0 : 1;
+
+      if ( not exists $vers{$package} and defined $version ){
+        # Upgrade to a version object.
+        my $dwim_version = eval { _dwim_version($version) };
+        croak "Version '$version' from $self->{filename} does not appear to be valid:\n$line\n\nThe fatal error was: $@\n"
+          unless defined $dwim_version;  # "0" is OK!
+        $vers{$package} = $dwim_version;
+      }
+    }
+
+    # VERSION defined with full package spec, i.e. $Module::VERSION
+    elsif ( $version_fullname && $version_package ) {
+      # we do NOT save this package in found @packages
+      $need_vers = 0 if $version_package eq $package;
+
+      unless ( defined $vers{$version_package} && length $vers{$version_package} ) {
+        $vers{$version_package} = $self->_evaluate_version_line( $version_sigil, $version_fullname, $line );
+      }
+    }
+
+    # first non-comment line in undeclared package main is VERSION
+    elsif ( $package eq 'main' && $version_fullname && !exists($vers{main}) ) {
+      $need_vers = 0;
+      my $v = $self->_evaluate_version_line( $version_sigil, $version_fullname, $line );
+      $vers{$package} = $v;
+      push( @packages, 'main' );
+    }
+
+    # first non-comment line in undeclared package defines package main
+    elsif ( $package eq 'main' && !exists($vers{main}) && $line =~ /\w/ ) {
+      $need_vers = 1;
+      $vers{main} = '';
+      push( @packages, 'main' );
+    }
+
+    # only keep if this is the first $VERSION seen
+    elsif ( $version_fullname && $need_vers ) {
+      $need_vers = 0;
+      my $v = $self->_evaluate_version_line( $version_sigil, $version_fullname, $line );
+
+      unless ( defined $vers{$package} && length $vers{$package} ) {
+        $vers{$package} = $v;
+      }
+    }
+  } # end loop over each line
+
+  if ( $self->{collect_pod} && length($pod_data) ) {
+    $pod{$pod_sect} = $pod_data;
+  }
+
+  if ( $self->{decode_pod} && $encoding ) {
+    require Encode;
+    $_ = Encode::decode( $encoding, $_ ) for values %pod;
+  }
+
+  $self->{versions} = \%vers;
+  $self->{packages} = \@packages;
+  $self->{pod} = \%pod;
+  $self->{pod_headings} = \@pod;
+}
+
+sub __uniq (@)
+{
+    my (%seen, $key);
+    grep !$seen{ $key = $_ }++, @_;
+}
+
+{
+my $pn = 0;
+sub _evaluate_version_line {
+  my $self = shift;
+  my( $sigil, $variable_name, $line ) = @_;
+
+  # We compile into a local sub because 'use version' would cause
+  # compiletime/runtime issues with local()
+  $pn++; # everybody gets their own package
+  my $eval = qq{ my \$dummy = q#  Hide from _packages_inside()
+    #; package Module::Metadata::_version::p${pn};
+    use version;
+    sub {
+      local $sigil$variable_name;
+      $line;
+      return \$$variable_name if defined \$$variable_name;
+      return \$Module::Metadata::_version::p${pn}::$variable_name;
+    };
+  };
+
+  $eval = $1 if $eval =~ m{^(.+)}s;
+
+  local $^W;
+  # Try to get the $VERSION
+  my $vsub = __clean_eval($eval);
+  # some modules say $VERSION <equal sign> $Foo::Bar::VERSION, but Foo::Bar isn't
+  # installed, so we need to hunt in ./lib for it
+  if ( $@ =~ /Can't locate/ && -d 'lib' ) {
+    local @INC = ('lib',@INC);
+    $vsub = __clean_eval($eval);
+  }
+  warn "Error evaling version line '$eval' in $self->{filename}: $@\n"
+    if $@;
+
+  (ref($vsub) eq 'CODE') or
+    croak "failed to build version sub for $self->{filename}";
+
+  my $result = eval { $vsub->() };
+  # FIXME: $eval is not the right thing to print here
+  croak "Could not get version from $self->{filename} by executing:\n$eval\n\nThe fatal error was: $@\n"
+    if $@;
+
+  # Upgrade it into a version object
+  my $version = eval { _dwim_version($result) };
+
+  # FIXME: $eval is not the right thing to print here
+  croak "Version '$result' from $self->{filename} does not appear to be valid:\n$eval\n\nThe fatal error was: $@\n"
+    unless defined $version; # "0" is OK!
+
+  return $version;
+}
+}
+
+# Try to DWIM when things fail the lax version test in obvious ways
+{
+  my @version_prep = (
+    # Best case, it just works
+    sub { return shift },
+
+    # If we still don't have a version, try stripping any
+    # trailing junk that is prohibited by lax rules
+    sub {
+      my $v = shift;
+      $v =~ s{([0-9])[a-z-].*$}{$1}i; # 1.23-alpha or 1.23b
+      return $v;
+    },
+
+    # Activestate apparently creates custom versions like '1.23_45_01', which
+    # cause version.pm to think it's an invalid alpha.  So check for that
+    # and strip them
+    sub {
+      my $v = shift;
+      my $num_dots = () = $v =~ m{(\.)}g;
+      my $num_unders = () = $v =~ m{(_)}g;
+      my $leading_v = substr($v,0,1) eq 'v';
+      if ( ! $leading_v && $num_dots < 2 && $num_unders > 1 ) {
+        $v =~ s{_}{}g;
+        $num_unders = () = $v =~ m{(_)}g;
+      }
+      return $v;
+    },
+
+    # Worst case, try numifying it like we would have before version objects
+    sub {
+      my $v = shift;
+      no warnings 'numeric';
+      return 0 + $v;
+    },
+
+  );
+
+  sub _dwim_version {
+    my ($result) = shift;
+
+    return $result if ref($result) eq 'version';
+
+    my ($version, $error);
+    for my $f (@version_prep) {
+      $result = $f->($result);
+      $version = eval { version->new($result) };
+      $error ||= $@ if $@; # capture first failure
+      last if defined $version;
+    }
+
+    croak $error unless defined $version;
+
+    return $version;
+  }
+}
+
+############################################################
+
+# accessors
+sub name            { $_[0]->{module}            }
+
+sub filename        { $_[0]->{filename}          }
+sub packages_inside { @{$_[0]->{packages}}       }
+sub pod_inside      { @{$_[0]->{pod_headings}}   }
+sub contains_pod    { 0+@{$_[0]->{pod_headings}} }
+
+sub version {
+    my $self = shift;
+    my $mod  = shift || $self->{module};
+    my $vers;
+    if ( defined( $mod ) && length( $mod ) &&
+         exists( $self->{versions}{$mod} ) ) {
+        return $self->{versions}{$mod};
+    }
+    else {
+        return undef;
+    }
+}
+
+sub pod {
+    my $self = shift;
+    my $sect = shift;
+    if ( defined( $sect ) && length( $sect ) &&
+         exists( $self->{pod}{$sect} ) ) {
+        return $self->{pod}{$sect};
+    }
+    else {
+        return undef;
+    }
+}
+
+sub is_indexable {
+  my ($self, $package) = @_;
+
+  my @indexable_packages = grep $_ ne 'main', $self->packages_inside;
+
+  # check for specific package, if provided
+  return !! grep $_ eq $package, @indexable_packages if $package;
+
+  # otherwise, check for any indexable packages at all
+  return !! @indexable_packages;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Module::Metadata - Gather package and POD information from perl module files
+
+=head1 VERSION
+
+version 1.000038
+
+=head1 SYNOPSIS
+
+  use Module::Metadata;
+
+  # information about a .pm file
+  my $info = Module::Metadata->new_from_file( $file );
+  my $version = $info->version;
+
+  # CPAN META 'provides' field for .pm files in a directory
+  my $provides = Module::Metadata->provides(
+    dir => 'lib', version => 2
+  );
+
+=head1 DESCRIPTION
+
+This module provides a standard way to gather metadata about a .pm file through
+(mostly) static analysis and (some) code execution.  When determining the
+version of a module, the C<$VERSION> assignment is C<eval>ed, as is traditional
+in the CPAN toolchain.
+
+=head1 CLASS METHODS
+
+=head2 C<< new_from_file($filename, collect_pod => 1, decode_pod => 1) >>
+
+Constructs a C<Module::Metadata> object given the path to a file.  Returns
+undef if the filename does not exist.
+
+C<collect_pod> is a optional boolean argument that determines whether POD
+data is collected and stored for reference.  POD data is not collected by
+default.  POD headings are always collected.
+
+If the file begins by an UTF-8, UTF-16BE or UTF-16LE byte-order mark, then
+it is skipped before processing, and the content of the file is also decoded
+appropriately starting from perl 5.8.
+
+Alternatively, if C<decode_pod> is set, it will decode the collected pod
+sections according to the C<=encoding> declaration.
+
+=head2 C<< new_from_handle($handle, $filename, collect_pod => 1, decode_pod => 1) >>
+
+This works just like C<new_from_file>, except that a handle can be provided
+as the first argument.
+
+Note that there is no validation to confirm that the handle is a handle or
+something that can act like one.  Passing something that isn't a handle will
+cause a exception when trying to read from it.  The C<filename> argument is
+mandatory or undef will be returned.
+
+You are responsible for setting the decoding layers on C<$handle> if
+required.
+
+=head2 C<< new_from_module($module, collect_pod => 1, inc => \@dirs, decode_pod => 1) >>
+
+Constructs a C<Module::Metadata> object given a module or package name.
+Returns undef if the module cannot be found.
+
+In addition to accepting the C<collect_pod> and C<decode_pod> arguments as
+described above, this method accepts a C<inc> argument which is a reference to
+an array of directories to search for the module.  If none are given, the
+default is @INC.
+
+If the file that contains the module begins by an UTF-8, UTF-16BE or
+UTF-16LE byte-order mark, then it is skipped before processing, and the
+content of the file is also decoded appropriately starting from perl 5.8.
+
+=head2 C<< find_module_by_name($module, \@dirs) >>
+
+Returns the path to a module given the module or package name. A list
+of directories can be passed in as an optional parameter, otherwise
+@INC is searched.
+
+Can be called as either an object or a class method.
+
+=head2 C<< find_module_dir_by_name($module, \@dirs) >>
+
+Returns the entry in C<@dirs> (or C<@INC> by default) that contains
+the module C<$module>. A list of directories can be passed in as an
+optional parameter, otherwise @INC is searched.
+
+Can be called as either an object or a class method.
+
+=head2 C<< provides( %options ) >>
+
+This is a convenience wrapper around C<package_versions_from_directory>
+to generate a CPAN META C<provides> data structure.  It takes key/value
+pairs.  Valid option keys include:
+
+=over
+
+=item version B<(required)>
+
+Specifies which version of the L<CPAN::Meta::Spec> should be used as
+the format of the C<provides> output.  Currently only '1.4' and '2'
+are supported (and their format is identical).  This may change in
+the future as the definition of C<provides> changes.
+
+The C<version> option is required.  If it is omitted or if
+an unsupported version is given, then C<provides> will throw an error.
+
+=item dir
+
+Directory to search recursively for F<.pm> files.  May not be specified with
+C<files>.
+
+=item files
+
+Array reference of files to examine.  May not be specified with C<dir>.
+
+=item prefix
+
+String to prepend to the C<file> field of the resulting output. This defaults
+to F<lib>, which is the common case for most CPAN distributions with their
+F<.pm> files in F<lib>.  This option ensures the META information has the
+correct relative path even when the C<dir> or C<files> arguments are
+absolute or have relative paths from a location other than the distribution
+root.
+
+=back
+
+For example, given C<dir> of 'lib' and C<prefix> of 'lib', the return value
+is a hashref of the form:
+
+  {
+    'Package::Name' => {
+      version => '0.123',
+      file => 'lib/Package/Name.pm'
+    },
+    'OtherPackage::Name' => ...
+  }
+
+=head2 C<< package_versions_from_directory($dir, \@files?) >>
+
+Scans C<$dir> for .pm files (unless C<@files> is given, in which case looks
+for those files in C<$dir> - and reads each file for packages and versions,
+returning a hashref of the form:
+
+  {
+    'Package::Name' => {
+      version => '0.123',
+      file => 'Package/Name.pm'
+    },
+    'OtherPackage::Name' => ...
+  }
+
+The C<DB> and C<main> packages are always omitted, as are any "private"
+packages that have leading underscores in the namespace (e.g.
+C<Foo::_private>)
+
+Note that the file path is relative to C<$dir> if that is specified.
+This B<must not> be used directly for CPAN META C<provides>.  See
+the C<provides> method instead.
+
+=head2 C<< log_info (internal) >>
+
+Used internally to perform logging; imported from Log::Contextual if
+Log::Contextual has already been loaded, otherwise simply calls warn.
+
+=head1 OBJECT METHODS
+
+=head2 C<< name() >>
+
+Returns the name of the package represented by this module. If there
+is more than one package, it makes a best guess based on the
+filename. If it's a script (i.e. not a *.pm) the package name is
+'main'.
+
+=head2 C<< version($package) >>
+
+Returns the version as defined by the $VERSION variable for the
+package as returned by the C<name> method if no arguments are
+given. If given the name of a package it will attempt to return the
+version of that package if it is specified in the file.
+
+=head2 C<< filename() >>
+
+Returns the absolute path to the file.
+Note that this file may not actually exist on disk yet, e.g. if the module was read from an in-memory filehandle.
+
+=head2 C<< packages_inside() >>
+
+Returns a list of packages. Note: this is a raw list of packages
+discovered (or assumed, in the case of C<main>).  It is not
+filtered for C<DB>, C<main> or private packages the way the
+C<provides> method does.  Invalid package names are not returned,
+for example "Foo:Bar".  Strange but valid package names are
+returned, for example "Foo::Bar::", and are left up to the caller
+on how to handle.
+
+=head2 C<< pod_inside() >>
+
+Returns a list of POD sections.
+
+=head2 C<< contains_pod() >>
+
+Returns true if there is any POD in the file.
+
+=head2 C<< pod($section) >>
+
+Returns the POD data in the given section.
+
+=head2 C<< is_indexable($package) >> or C<< is_indexable() >>
+
+Available since version 1.000020.
+
+Returns a boolean indicating whether the package (if provided) or any package
+(otherwise) is eligible for indexing by PAUSE, the Perl Authors Upload Server.
+Note This only checks for valid C<package> declarations, and does not take any
+ownership information into account.
+
+=head1 SUPPORT
+
+Bugs may be submitted through L<the RT bug tracker|https://rt.cpan.org/Public/Dist/Display.html?Name=Module-Metadata>
+(or L<bug-Module-Metadata@rt.cpan.org|mailto:bug-Module-Metadata@rt.cpan.org>).
+
+There is also a mailing list available for users of this distribution, at
+L<http://lists.perl.org/list/cpan-workers.html>.
+
+There is also an irc channel available for users of this distribution, at
+L<C<#toolchain> on C<irc.perl.org>|irc://irc.perl.org/#toolchain>.
+
+=head1 AUTHOR
+
+Original code from Module::Build::ModuleInfo by Ken Williams
+<kwilliams@cpan.org>, Randy W. Sims <RandyS@ThePierianSpring.org>
+
+Released as Module::Metadata by Matt S Trout (mst) <mst@shadowcat.co.uk> with
+assistance from David Golden (xdg) <dagolden@cpan.org>.
+
+=head1 CONTRIBUTORS
+
+=for stopwords Karen Etheridge David Golden Vincent Pit Matt S Trout Chris Nehren Graham Knop Olivier Mengué Tomas Doran Christian Walde Craig A. Berry Tatsuhiko Miyagawa tokuhirom 'BinGOs' Williams Mitchell Steinbrunner Edward Zborowski Gareth Harper James Raspass Jerry D. Hedden Josh Jore Kent Fredric Leon Timmermans Peter Rabbitson Steve Hay
+
+=over 4
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+David Golden <dagolden@cpan.org>
+
+=item *
+
+Vincent Pit <perl@profvince.com>
+
+=item *
+
+Matt S Trout <mst@shadowcat.co.uk>
+
+=item *
+
+Chris Nehren <apeiron@cpan.org>
+
+=item *
+
+Graham Knop <haarg@haarg.org>
+
+=item *
+
+Olivier Mengué <dolmen@cpan.org>
+
+=item *
+
+Tomas Doran <bobtfish@bobtfish.net>
+
+=item *
+
+Christian Walde <walde.christian@googlemail.com>
+
+=item *
+
+Craig A. Berry <cberry@cpan.org>
+
+=item *
+
+Tatsuhiko Miyagawa <miyagawa@bulknews.net>
+
+=item *
+
+tokuhirom <tokuhirom@gmail.com>
+
+=item *
+
+Chris 'BinGOs' Williams <chris@bingosnet.co.uk>
+
+=item *
+
+David Mitchell <davem@iabyn.com>
+
+=item *
+
+David Steinbrunner <dsteinbrunner@pobox.com>
+
+=item *
+
+Edward Zborowski <ed@rubensteintech.com>
+
+=item *
+
+Gareth Harper <gareth@broadbean.com>
+
+=item *
+
+James Raspass <jraspass@gmail.com>
+
+=item *
+
+Jerry D. Hedden <jdhedden@cpan.org>
+
+=item *
+
+Josh Jore <jjore@cpan.org>
+
+=item *
+
+Kent Fredric <kentnl@cpan.org>
+
+=item *
+
+Leon Timmermans <fawaka@gmail.com>
+
+=item *
+
+Peter Rabbitson <ribasushi@cpan.org>
+
+=item *
+
+Steve Hay <steve.m.hay@googlemail.com>
+
+=back
+
+=head1 COPYRIGHT & LICENSE
+
+Original code Copyright (c) 2001-2011 Ken Williams.
+Additional code Copyright (c) 2010-2011 Matt Trout and David Golden.
+All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut

git/usr/share/perl5/core_perl/Net/Cmd.pm

@@ -0,0 +1,910 @@
+# Net::Cmd.pm
+#
+# Copyright (C) 1995-2006 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2016, 2020, 2022 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::Cmd;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Exporter;
+use Symbol 'gensym';
+use Errno 'EINTR';
+
+BEGIN {
+  if (ord "A" == 193) {
+    require Convert::EBCDIC;
+
+    #    Convert::EBCDIC->import;
+  }
+}
+
+our $VERSION = "3.15";
+our @ISA     = qw(Exporter);
+our @EXPORT  = qw(CMD_INFO CMD_OK CMD_MORE CMD_REJECT CMD_ERROR CMD_PENDING);
+
+use constant CMD_INFO    => 1;
+use constant CMD_OK      => 2;
+use constant CMD_MORE    => 3;
+use constant CMD_REJECT  => 4;
+use constant CMD_ERROR   => 5;
+use constant CMD_PENDING => 0;
+
+use constant DEF_REPLY_CODE => 421;
+
+my %debug = ();
+
+my $tr = ord "A" == 193 ? Convert::EBCDIC->new() : undef;
+
+sub toebcdic {
+  my $cmd = shift;
+
+  unless (exists ${*$cmd}{'net_cmd_asciipeer'}) {
+    my $string    = $_[0];
+    my $ebcdicstr = $tr->toebcdic($string);
+    ${*$cmd}{'net_cmd_asciipeer'} = $string !~ /^\d+/ && $ebcdicstr =~ /^\d+/;
+  }
+
+  ${*$cmd}{'net_cmd_asciipeer'}
+    ? $tr->toebcdic($_[0])
+    : $_[0];
+}
+
+
+sub toascii {
+  my $cmd = shift;
+  ${*$cmd}{'net_cmd_asciipeer'}
+    ? $tr->toascii($_[0])
+    : $_[0];
+}
+
+
+sub _print_isa {
+  no strict 'refs'; ## no critic (TestingAndDebugging::ProhibitNoStrict)
+
+  my $pkg = shift;
+  my $cmd = $pkg;
+
+  $debug{$pkg} ||= 0;
+
+  my %done = ();
+  my @do   = ($pkg);
+  my %spc  = ($pkg, "");
+
+  while ($pkg = shift @do) {
+    next if defined $done{$pkg};
+
+    $done{$pkg} = 1;
+
+    my $v =
+      defined ${"${pkg}::VERSION"}
+      ? "(" . ${"${pkg}::VERSION"} . ")"
+      : "";
+
+    my $spc = $spc{$pkg};
+    $cmd->debug_print(1, "${spc}${pkg}${v}\n");
+
+    if (@{"${pkg}::ISA"}) {
+      @spc{@{"${pkg}::ISA"}} = ("  " . $spc{$pkg}) x @{"${pkg}::ISA"};
+      unshift(@do, @{"${pkg}::ISA"});
+    }
+  }
+}
+
+
+sub debug {
+  @_ == 1 or @_ == 2 or croak 'usage: $obj->debug([$level])';
+
+  my ($cmd, $level) = @_;
+  my $pkg    = ref($cmd) || $cmd;
+  my $oldval = 0;
+
+  if (ref($cmd)) {
+    $oldval = ${*$cmd}{'net_cmd_debug'} || 0;
+  }
+  else {
+    $oldval = $debug{$pkg} || 0;
+  }
+
+  return $oldval
+    unless @_ == 2;
+
+  $level = $debug{$pkg} || 0
+    unless defined $level;
+
+  _print_isa($pkg)
+    if ($level && !exists $debug{$pkg});
+
+  if (ref($cmd)) {
+    ${*$cmd}{'net_cmd_debug'} = $level;
+  }
+  else {
+    $debug{$pkg} = $level;
+  }
+
+  $oldval;
+}
+
+
+sub message {
+  @_ == 1 or croak 'usage: $obj->message()';
+
+  my $cmd = shift;
+
+  wantarray
+    ? @{${*$cmd}{'net_cmd_resp'}}
+    : join("", @{${*$cmd}{'net_cmd_resp'}});
+}
+
+
+sub debug_text { $_[2] }
+
+
+sub debug_print {
+  my ($cmd, $out, $text) = @_;
+  print STDERR $cmd, ($out ? '>>> ' : '<<< '), $cmd->debug_text($out, $text);
+}
+
+
+sub code {
+  @_ == 1 or croak 'usage: $obj->code()';
+
+  my $cmd = shift;
+
+  ${*$cmd}{'net_cmd_code'} = $cmd->DEF_REPLY_CODE
+    unless exists ${*$cmd}{'net_cmd_code'};
+
+  ${*$cmd}{'net_cmd_code'};
+}
+
+
+sub status {
+  @_ == 1 or croak 'usage: $obj->status()';
+
+  my $cmd = shift;
+
+  substr(${*$cmd}{'net_cmd_code'}, 0, 1);
+}
+
+
+sub set_status {
+  @_ == 3 or croak 'usage: $obj->set_status($code, $resp)';
+
+  my $cmd = shift;
+  my ($code, $resp) = @_;
+
+  $resp = defined $resp ? [$resp] : []
+    unless ref($resp);
+
+  (${*$cmd}{'net_cmd_code'}, ${*$cmd}{'net_cmd_resp'}) = ($code, $resp);
+
+  1;
+}
+
+sub _syswrite_with_timeout {
+  my $cmd = shift;
+  my $line = shift;
+
+  my $len    = length($line);
+  my $offset = 0;
+  my $win    = "";
+  vec($win, fileno($cmd), 1) = 1;
+  my $timeout = $cmd->timeout || undef;
+  my $initial = time;
+  my $pending = $timeout;
+
+  local $SIG{PIPE} = 'IGNORE' unless $^O eq 'MacOS';
+
+  while ($len) {
+    my $wout;
+    my $nfound = select(undef, $wout = $win, undef, $pending);
+    if ((defined $nfound and $nfound > 0) or -f $cmd)    # -f for testing on win32
+    {
+      my $w = syswrite($cmd, $line, $len, $offset);
+      if (! defined($w) ) {
+        my $err = $!;
+        $cmd->close;
+        $cmd->_set_status_closed($err);
+        return;
+      }
+      $len -= $w;
+      $offset += $w;
+    }
+    elsif ($nfound == -1) {
+      if ( $! == EINTR ) {
+        if ( defined($timeout) ) {
+          redo if ($pending = $timeout - ( time - $initial ) ) > 0;
+          $cmd->_set_status_timeout;
+          return;
+        }
+        redo;
+      }
+      my $err = $!;
+      $cmd->close;
+      $cmd->_set_status_closed($err);
+      return;
+    }
+    else {
+      $cmd->_set_status_timeout;
+      return;
+    }
+  }
+
+  return 1;
+}
+
+sub _set_status_timeout {
+  my $cmd = shift;
+  my $pkg = ref($cmd) || $cmd;
+
+  $cmd->set_status($cmd->DEF_REPLY_CODE, "[$pkg] Timeout");
+  carp(ref($cmd) . ": " . (caller(1))[3] . "(): timeout") if $cmd->debug;
+}
+
+sub _set_status_closed {
+  my $cmd = shift;
+  my $err = shift;
+  my $pkg = ref($cmd) || $cmd;
+
+  $cmd->set_status($cmd->DEF_REPLY_CODE, "[$pkg] Connection closed");
+  carp(ref($cmd) . ": " . (caller(1))[3]
+    . "(): unexpected EOF on command channel: $err") if $cmd->debug;
+}
+
+sub _is_closed {
+  my $cmd = shift;
+  if (!defined fileno($cmd)) {
+     $cmd->_set_status_closed($!);
+     return 1;
+  }
+  return 0;
+}
+
+sub command {
+  my $cmd = shift;
+
+  return $cmd
+    if $cmd->_is_closed;
+
+  $cmd->dataend()
+    if (exists ${*$cmd}{'net_cmd_last_ch'});
+
+  if (scalar(@_)) {
+    my $str = join(
+      " ",
+      map {
+        /\n/
+          ? do { my $n = $_; $n =~ tr/\n/ /; $n }
+          : $_;
+        } @_
+    );
+    $str = $cmd->toascii($str) if $tr;
+    $str .= "\015\012";
+
+    $cmd->debug_print(1, $str)
+      if ($cmd->debug);
+
+    # though documented to return undef on failure, the legacy behavior
+    # was to return $cmd even on failure, so this odd construct does that
+    $cmd->_syswrite_with_timeout($str)
+      or return $cmd;
+  }
+
+  $cmd;
+}
+
+
+sub ok {
+  @_ == 1 or croak 'usage: $obj->ok()';
+
+  my $code = $_[0]->code;
+  0 < $code && $code < 400;
+}
+
+
+sub unsupported {
+  my $cmd = shift;
+
+  $cmd->set_status(580, 'Unsupported command');
+
+  0;
+}
+
+
+sub getline {
+  my $cmd = shift;
+
+  ${*$cmd}{'net_cmd_lines'} ||= [];
+
+  return shift @{${*$cmd}{'net_cmd_lines'}}
+    if scalar(@{${*$cmd}{'net_cmd_lines'}});
+
+  my $partial = defined(${*$cmd}{'net_cmd_partial'}) ? ${*$cmd}{'net_cmd_partial'} : "";
+
+  return
+    if $cmd->_is_closed;
+
+  my $fd = fileno($cmd);
+  my $rin = "";
+  vec($rin, $fd, 1) = 1;
+
+  my $buf;
+
+  until (scalar(@{${*$cmd}{'net_cmd_lines'}})) {
+    my $timeout = $cmd->timeout || undef;
+    my $rout;
+
+    my $select_ret = select($rout = $rin, undef, undef, $timeout);
+    if ($select_ret > 0) {
+      unless (sysread($cmd, $buf = "", 1024)) {
+        my $err = $!;
+        $cmd->close;
+        $cmd->_set_status_closed($err);
+        return;
+      }
+
+      substr($buf, 0, 0) = $partial;    ## prepend from last sysread
+
+      my @buf = split(/\015?\012/, $buf, -1);    ## break into lines
+
+      $partial = pop @buf;
+
+      push(@{${*$cmd}{'net_cmd_lines'}}, map {"$_\n"} @buf);
+
+    }
+    else {
+      $cmd->_set_status_timeout;
+      return;
+    }
+  }
+
+  ${*$cmd}{'net_cmd_partial'} = $partial;
+
+  if ($tr) {
+    foreach my $ln (@{${*$cmd}{'net_cmd_lines'}}) {
+      $ln = $cmd->toebcdic($ln);
+    }
+  }
+
+  shift @{${*$cmd}{'net_cmd_lines'}};
+}
+
+
+sub ungetline {
+  my ($cmd, $str) = @_;
+
+  ${*$cmd}{'net_cmd_lines'} ||= [];
+  unshift(@{${*$cmd}{'net_cmd_lines'}}, $str);
+}
+
+
+sub parse_response {
+  return ()
+    unless $_[1] =~ s/^(\d\d\d)(.?)//o;
+  ($1, $2 eq "-");
+}
+
+
+sub response {
+  my $cmd = shift;
+  my ($code, $more) = (undef) x 2;
+
+  $cmd->set_status($cmd->DEF_REPLY_CODE, undef); # initialize the response
+
+  while (1) {
+    my $str = $cmd->getline();
+
+    return CMD_ERROR
+      unless defined($str);
+
+    $cmd->debug_print(0, $str)
+      if ($cmd->debug);
+
+    ($code, $more) = $cmd->parse_response($str);
+    unless (defined $code) {
+      carp("$cmd: response(): parse error in '$str'") if ($cmd->debug);
+      $cmd->ungetline($str);
+      $@ = $str;   # $@ used as tunneling hack
+      return CMD_ERROR;
+    }
+
+    ${*$cmd}{'net_cmd_code'} = $code;
+
+    push(@{${*$cmd}{'net_cmd_resp'}}, $str);
+
+    last unless ($more);
+  }
+
+  return unless defined $code;
+  substr($code, 0, 1);
+}
+
+
+sub read_until_dot {
+  my $cmd = shift;
+  my $fh  = shift;
+  my $arr = [];
+
+  while (1) {
+    my $str = $cmd->getline() or return;
+
+    $cmd->debug_print(0, $str)
+      if ($cmd->debug & 4);
+
+    last if ($str =~ /^\.\r?\n/o);
+
+    $str =~ s/^\.\././o;
+
+    if (defined $fh) {
+      print $fh $str;
+    }
+    else {
+      push(@$arr, $str);
+    }
+  }
+
+  $arr;
+}
+
+
+sub datasend {
+  my $cmd  = shift;
+  my $arr  = @_ == 1 && ref($_[0]) ? $_[0] : \@_;
+  my $line = join("", @$arr);
+
+  # Perls < 5.10.1 (with the exception of 5.8.9) have a performance problem with
+  # the substitutions below when dealing with strings stored internally in
+  # UTF-8, so downgrade them (if possible).
+  # Data passed to datasend() should be encoded to octets upstream already so
+  # shouldn't even have the UTF-8 flag on to start with, but if it so happens
+  # that the octets are stored in an upgraded string (as can sometimes occur)
+  # then they would still downgrade without fail anyway.
+  # Only Unicode codepoints > 0xFF stored in an upgraded string will fail to
+  # downgrade. We fail silently in that case, and a "Wide character in print"
+  # warning will be emitted later by syswrite().
+  utf8::downgrade($line, 1) if $] < 5.010001 && $] != 5.008009;
+
+  return 0
+    if $cmd->_is_closed;
+
+  my $last_ch = ${*$cmd}{'net_cmd_last_ch'};
+
+  # We have not send anything yet, so last_ch = "\012" means we are at the start of a line
+  $last_ch = ${*$cmd}{'net_cmd_last_ch'} = "\012" unless defined $last_ch;
+
+  return 1 unless length $line;
+
+  if ($cmd->debug) {
+    foreach my $b (split(/\n/, $line)) {
+      $cmd->debug_print(1, "$b\n");
+    }
+  }
+
+  $line =~ tr/\r\n/\015\012/ unless "\r" eq "\015";
+
+  my $first_ch = '';
+
+  if ($last_ch eq "\015") {
+    # Remove \012 so it does not get prefixed with another \015 below
+    # and escape the . if there is one following it because the fixup
+    # below will not find it
+    $first_ch = "\012" if $line =~ s/^\012(\.?)/$1$1/;
+  }
+  elsif ($last_ch eq "\012") {
+    # Fixup below will not find the . as the first character of the buffer
+    $first_ch = "." if $line =~ /^\./;
+  }
+
+  $line =~ s/\015?\012(\.?)/\015\012$1$1/sg;
+
+  substr($line, 0, 0) = $first_ch;
+
+  ${*$cmd}{'net_cmd_last_ch'} = substr($line, -1, 1);
+
+  $cmd->_syswrite_with_timeout($line)
+    or return;
+
+  1;
+}
+
+
+sub rawdatasend {
+  my $cmd  = shift;
+  my $arr  = @_ == 1 && ref($_[0]) ? $_[0] : \@_;
+  my $line = join("", @$arr);
+
+  return 0
+    if $cmd->_is_closed;
+
+  return 1
+    unless length($line);
+
+  if ($cmd->debug) {
+    my $b = "$cmd>>> ";
+    print STDERR $b, join("\n$b", split(/\n/, $line)), "\n";
+  }
+
+  $cmd->_syswrite_with_timeout($line)
+    or return;
+
+  1;
+}
+
+
+sub dataend {
+  my $cmd = shift;
+
+  return 0
+    if $cmd->_is_closed;
+
+  my $ch = ${*$cmd}{'net_cmd_last_ch'};
+  my $tosend;
+
+  if (!defined $ch) {
+    return 1;
+  }
+  elsif ($ch ne "\012") {
+    $tosend = "\015\012";
+  }
+
+  $tosend .= ".\015\012";
+
+  $cmd->debug_print(1, ".\n")
+    if ($cmd->debug);
+
+  $cmd->_syswrite_with_timeout($tosend)
+    or return 0;
+
+  delete ${*$cmd}{'net_cmd_last_ch'};
+
+  $cmd->response() == CMD_OK;
+}
+
+# read and write to tied filehandle
+sub tied_fh {
+  my $cmd = shift;
+  ${*$cmd}{'net_cmd_readbuf'} = '';
+  my $fh = gensym();
+  tie *$fh, ref($cmd), $cmd;
+  return $fh;
+}
+
+# tie to myself
+sub TIEHANDLE {
+  my $class = shift;
+  my $cmd   = shift;
+  return $cmd;
+}
+
+# Tied filehandle read.  Reads requested data length, returning
+# end-of-file when the dot is encountered.
+sub READ {
+  my $cmd = shift;
+  my ($len, $offset) = @_[1, 2];
+  return unless exists ${*$cmd}{'net_cmd_readbuf'};
+  my $done = 0;
+  while (!$done and length(${*$cmd}{'net_cmd_readbuf'}) < $len) {
+    ${*$cmd}{'net_cmd_readbuf'} .= $cmd->getline() or return;
+    $done++ if ${*$cmd}{'net_cmd_readbuf'} =~ s/^\.\r?\n\Z//m;
+  }
+
+  $_[0] = '';
+  substr($_[0], $offset + 0) = substr(${*$cmd}{'net_cmd_readbuf'}, 0, $len);
+  substr(${*$cmd}{'net_cmd_readbuf'}, 0, $len) = '';
+  delete ${*$cmd}{'net_cmd_readbuf'} if $done;
+
+  return length $_[0];
+}
+
+
+sub READLINE {
+  my $cmd = shift;
+
+  # in this context, we use the presence of readbuf to
+  # indicate that we have not yet reached the eof
+  return unless exists ${*$cmd}{'net_cmd_readbuf'};
+  my $line = $cmd->getline;
+  return if $line =~ /^\.\r?\n/;
+  $line;
+}
+
+
+sub PRINT {
+  my $cmd = shift;
+  my ($buf, $len, $offset) = @_;
+  $len ||= length($buf);
+  $offset += 0;
+  return unless $cmd->datasend(substr($buf, $offset, $len));
+  ${*$cmd}{'net_cmd_sending'}++;    # flag that we should call dataend()
+  return $len;
+}
+
+
+sub CLOSE {
+  my $cmd = shift;
+  my $r = exists(${*$cmd}{'net_cmd_sending'}) ? $cmd->dataend : 1;
+  delete ${*$cmd}{'net_cmd_readbuf'};
+  delete ${*$cmd}{'net_cmd_sending'};
+  $r;
+}
+
+1;
+
+__END__
+
+
+=head1 NAME
+
+Net::Cmd - Network Command class (as used by FTP, SMTP etc)
+
+=head1 SYNOPSIS
+
+    use Net::Cmd;
+
+    @ISA = qw(Net::Cmd);
+
+=head1 DESCRIPTION
+
+C<Net::Cmd> is a collection of methods that can be inherited by a sub-class
+of C<IO::Socket::INET>. These methods implement the functionality required for a
+command based protocol, for example FTP and SMTP.
+
+If your sub-class does not also derive from C<IO::Socket::INET> or similar (e.g.
+C<IO::Socket::IP>, C<IO::Socket::INET6> or C<IO::Socket::SSL>) then you must
+provide the following methods by other means yourself: C<close()> and
+C<timeout()>.
+
+=head2 Public Methods
+
+These methods provide a user interface to the C<Net::Cmd> object.
+
+=over 4
+
+=item C<debug($level)>
+
+Set the level of debug information for this object. If C<$level> is not given
+then the current state is returned. Otherwise the state is changed to 
+C<$level> and the previous state returned. 
+
+Different packages
+may implement different levels of debug but a non-zero value results in 
+copies of all commands and responses also being sent to STDERR.
+
+If C<$level> is C<undef> then the debug level will be set to the default
+debug level for the class.
+
+This method can also be called as a I<static> method to set/get the default
+debug level for a given class.
+
+=item C<message()>
+
+Returns the text message returned from the last command. In a scalar
+context it returns a single string, in a list context it will return
+each line as a separate element. (See L<PSEUDO RESPONSES> below.)
+
+=item C<code()>
+
+Returns the 3-digit code from the last command. If a command is pending
+then the value 0 is returned. (See L<PSEUDO RESPONSES> below.)
+
+=item C<ok()>
+
+Returns non-zero if the last code value was greater than zero and
+less than 400. This holds true for most command servers. Servers
+where this does not hold may override this method.
+
+=item C<status()>
+
+Returns the most significant digit of the current status code. If a command
+is pending then C<CMD_PENDING> is returned.
+
+=item C<datasend($data)>
+
+Send data to the remote server, converting LF to CRLF. Any line starting
+with a '.' will be prefixed with another '.'.
+C<$data> may be an array or a reference to an array.
+The C<$data> passed in must be encoded by the caller to octets of whatever
+encoding is required, e.g. by using the Encode module's C<encode()> function.
+
+=item C<dataend()>
+
+End the sending of data to the remote server. This is done by ensuring that
+the data already sent ends with CRLF then sending '.CRLF' to end the
+transmission. Once this data has been sent C<dataend> calls C<response> and
+returns true if C<response> returns CMD_OK.
+
+=back
+
+=head2 Protected Methods
+
+These methods are not intended to be called by the user, but used or 
+over-ridden by a sub-class of C<Net::Cmd>
+
+=over 4
+
+=item C<debug_print($dir, $text)>
+
+Print debugging information. C<$dir> denotes the direction I<true> being
+data being sent to the server. Calls C<debug_text> before printing to
+STDERR.
+
+=item C<debug_text($dir, $text)>
+
+This method is called to print debugging information. C<$text> is
+the text being sent. The method should return the text to be printed.
+
+This is primarily meant for the use of modules such as FTP where passwords
+are sent, but we do not want to display them in the debugging information.
+
+=item C<command($cmd[, $args, ... ])>
+
+Send a command to the command server. All arguments are first joined with
+a space character and CRLF is appended, this string is then sent to the
+command server.
+
+Returns undef upon failure.
+
+=item C<unsupported()>
+
+Sets the status code to 580 and the response text to 'Unsupported command'.
+Returns zero.
+
+=item C<response()>
+
+Obtain a response from the server. Upon success the most significant digit
+of the status code is returned. Upon failure, timeout etc., I<CMD_ERROR> is
+returned.
+
+=item C<parse_response($text)>
+
+This method is called by C<response> as a method with one argument. It should
+return an array of 2 values, the 3-digit status code and a flag which is true
+when this is part of a multi-line response and this line is not the last.
+
+=item C<getline()>
+
+Retrieve one line, delimited by CRLF, from the remote server. Returns I<undef>
+upon failure.
+
+B<NOTE>: If you do use this method for any reason, please remember to add
+some C<debug_print> calls into your method.
+
+=item C<ungetline($text)>
+
+Unget a line of text from the server.
+
+=item C<rawdatasend($data)>
+
+Send data to the remote server without performing any conversions. C<$data>
+is a scalar.
+As with C<datasend()>, the C<$data> passed in must be encoded by the caller
+to octets of whatever encoding is required, e.g. by using the Encode module's
+C<encode()> function.
+
+=item C<read_until_dot()>
+
+Read data from the remote server until a line consisting of a single '.'.
+Any lines starting with '..' will have one of the '.'s removed.
+
+Returns a reference to a list containing the lines, or I<undef> upon failure.
+
+=item C<tied_fh()>
+
+Returns a filehandle tied to the Net::Cmd object.  After issuing a
+command, you may read from this filehandle using read() or <>.  The
+filehandle will return EOF when the final dot is encountered.
+Similarly, you may write to the filehandle in order to send data to
+the server after issuing a command that expects data to be written.
+
+See the Net::POP3 and Net::SMTP modules for examples of this.
+
+=back
+
+=head2 Pseudo Responses
+
+Normally the values returned by C<message()> and C<code()> are
+obtained from the remote server, but in a few circumstances, as
+detailed below, C<Net::Cmd> will return values that it sets. You
+can alter this behavior by overriding DEF_REPLY_CODE() to specify
+a different default reply code, or overriding one of the specific
+error handling methods below.
+
+=over 4
+
+=item Initial value
+
+Before any command has executed or if an unexpected error occurs
+C<code()> will return "421" (temporary connection failure) and
+C<message()> will return undef.
+
+=item Connection closed
+
+If the underlying C<IO::Handle> is closed, or if there are
+any read or write failures, the file handle will be forced closed,
+and C<code()> will return "421" (temporary connection failure)
+and C<message()> will return "[$pkg] Connection closed"
+(where $pkg is the name of the class that subclassed C<Net::Cmd>).
+The _set_status_closed() method can be overridden to set a different
+message (by calling set_status()) or otherwise trap this error.
+
+=item Timeout
+
+If there is a read or write timeout C<code()> will return "421"
+(temporary connection failure) and C<message()> will return
+"[$pkg] Timeout" (where $pkg is the name of the class
+that subclassed C<Net::Cmd>). The _set_status_timeout() method
+can be overridden to set a different message (by calling set_status())
+or otherwise trap this error.
+
+=back
+
+=head1 EXPORTS
+
+The following symbols are, or can be, exported by this module:
+
+=over 4
+
+=item Default Exports
+
+C<CMD_INFO>,
+C<CMD_OK>,
+C<CMD_MORE>,
+C<CMD_REJECT>,
+C<CMD_ERROR>,
+C<CMD_PENDING>.
+
+(These correspond to possible results of C<response()> and C<status()>.)
+
+=item Optional Exports
+
+I<None>.
+
+=item Export Tags
+
+I<None>.
+
+=back
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-2006 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2016, 2020, 2022 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/Config.pm

@@ -0,0 +1,381 @@
+# Net::Config.pm
+#
+# Copyright (C) 2000 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2014, 2016, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::Config;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Exporter;
+use Socket qw(inet_aton inet_ntoa);
+
+our @EXPORT  = qw(%NetConfig);
+our @ISA     = qw(Net::LocalCfg Exporter);
+our $VERSION = "3.15";
+
+our($CONFIGURE, $LIBNET_CFG);
+
+eval {
+  local @INC = @INC;
+  pop @INC if $INC[-1] eq '.';
+  local $SIG{__DIE__};
+  require Net::LocalCfg;
+};
+
+our %NetConfig = (
+  nntp_hosts      => [],
+  snpp_hosts      => [],
+  pop3_hosts      => [],
+  smtp_hosts      => [],
+  ph_hosts        => [],
+  daytime_hosts   => [],
+  time_hosts      => [],
+  inet_domain     => undef,
+  ftp_firewall    => undef,
+  ftp_ext_passive => 1,
+  ftp_int_passive => 1,
+  test_hosts      => 1,
+  test_exist      => 1,
+);
+
+#
+# Try to get as much configuration info as possible from InternetConfig
+#
+{
+## no critic (BuiltinFunctions::ProhibitStringyEval)
+$^O eq 'MacOS' and eval <<TRY_INTERNET_CONFIG;
+use Mac::InternetConfig;
+
+{
+my %nc = (
+    nntp_hosts      => [ \$InternetConfig{ kICNNTPHost() } ],
+    pop3_hosts      => [ \$InternetConfig{ kICMailAccount() } =~ /\@(.*)/ ],
+    smtp_hosts      => [ \$InternetConfig{ kICSMTPHost() } ],
+    ftp_testhost    => \$InternetConfig{ kICFTPHost() } ? \$InternetConfig{ kICFTPHost()} : undef,
+    ph_hosts        => [ \$InternetConfig{ kICPhHost() }   ],
+    ftp_ext_passive => \$InternetConfig{"646F676F\xA5UsePassiveMode"} || 0,
+    ftp_int_passive => \$InternetConfig{"646F676F\xA5UsePassiveMode"} || 0,
+    socks_hosts     => 
+        \$InternetConfig{ kICUseSocks() }    ? [ \$InternetConfig{ kICSocksHost() }    ] : [],
+    ftp_firewall    => 
+        \$InternetConfig{ kICUseFTPProxy() } ? [ \$InternetConfig{ kICFTPProxyHost() } ] : [],
+);
+\@NetConfig{keys %nc} = values %nc;
+}
+TRY_INTERNET_CONFIG
+}
+
+my $file = __FILE__;
+my $ref;
+$file =~ s/Config.pm/libnet.cfg/;
+if (-f $file) {
+  $ref = eval { local $SIG{__DIE__}; do $file };
+  if (ref($ref) eq 'HASH') {
+    %NetConfig = (%NetConfig, %{$ref});
+    $LIBNET_CFG = $file;
+  }
+}
+if ($< == $> and !$CONFIGURE) {
+  my $home = eval { local $SIG{__DIE__}; (getpwuid($>))[7] } || $ENV{HOME};
+  $home ||= $ENV{HOMEDRIVE} . ($ENV{HOMEPATH} || '') if defined $ENV{HOMEDRIVE};
+  if (defined $home) {
+    $file      = $home . "/.libnetrc";
+    $ref       = eval { local $SIG{__DIE__}; do $file } if -f $file;
+    %NetConfig = (%NetConfig, %{$ref})
+      if ref($ref) eq 'HASH';
+  }
+}
+my ($k, $v);
+while (($k, $v) = each %NetConfig) {
+  $NetConfig{$k} = [$v]
+    if ($k =~ /_hosts$/ and $k ne "test_hosts" and defined($v) and !ref($v));
+}
+
+# Take a hostname and determine if it is inside the firewall
+
+
+sub requires_firewall {
+  shift;    # ignore package
+  my $host = shift;
+
+  return 0 unless defined $NetConfig{'ftp_firewall'};
+
+  $host = inet_aton($host) or return -1;
+  $host = inet_ntoa($host);
+
+  if (exists $NetConfig{'local_netmask'}) {
+    my $quad = unpack("N", pack("C*", split(/\./, $host)));
+    my $list = $NetConfig{'local_netmask'};
+    $list = [$list] unless ref($list);
+    foreach (@$list) {
+      my ($net, $bits) = (m#^(\d+\.\d+\.\d+\.\d+)/(\d+)$#) or next;
+      my $mask = ~0 << (32 - $bits);
+      my $addr = unpack("N", pack("C*", split(/\./, $net)));
+
+      return 0 if (($addr & $mask) == ($quad & $mask));
+    }
+    return 1;
+  }
+
+  return 0;
+}
+
+*is_external = \&requires_firewall;
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::Config - Local configuration data for libnet
+
+=head1 SYNOPSIS
+
+    use Net::Config qw(%NetConfig);
+
+=head1 DESCRIPTION
+
+C<Net::Config> holds configuration data for the modules in the libnet
+distribution. During installation you will be asked for these values.
+
+The configuration data is held globally in a file in the perl installation
+tree, but a user may override any of these values by providing their own. This
+can be done by having a C<.libnetrc> file in their home directory. This file
+should return a reference to a HASH containing the keys described below.
+For example
+
+    # .libnetrc
+    {
+        nntp_hosts => [ "my_preferred_host" ],
+        ph_hosts   => [ "my_ph_server" ],
+    }
+    __END__
+
+=head2 Class Methods
+
+C<Net::Config> defines the following methods. They are methods as they are
+invoked as class methods. This is because C<Net::Config> inherits from
+C<Net::LocalCfg> so you can override these methods if you want.
+
+=over 4
+
+=item C<requires_firewall($host)>
+
+Attempts to determine if a given host is outside your firewall. Possible
+return values are.
+
+  -1  Cannot lookup hostname
+   0  Host is inside firewall (or there is no ftp_firewall entry)
+   1  Host is outside the firewall
+
+This is done by using hostname lookup and the C<local_netmask> entry in
+the configuration data.
+
+=back
+
+=head2 NetConfig Values
+
+=over 4
+
+=item nntp_hosts
+
+=item snpp_hosts
+
+=item pop3_hosts
+
+=item smtp_hosts
+
+=item ph_hosts
+
+=item daytime_hosts
+
+=item time_hosts
+
+Each is a reference to an array of hostnames (in order of preference),
+which should be used for the given protocol
+
+=item inet_domain
+
+Your internet domain name
+
+=item ftp_firewall
+
+If you have an FTP proxy firewall (B<NOT> an HTTP or SOCKS firewall)
+then this value should be set to the firewall hostname. If your firewall
+does not listen to port 21, then this value should be set to
+C<"hostname:port"> (eg C<"hostname:99">)
+
+=item ftp_firewall_type
+
+There are many different ftp firewall products available. But unfortunately
+there is no standard for how to traverse a firewall.  The list below shows the
+sequence of commands that Net::FTP will use
+
+  user        Username for remote host
+  pass        Password for remote host
+  fwuser      Username for firewall
+  fwpass      Password for firewall
+  remote.host The hostname of the remote ftp server
+
+=over 4
+
+=item 0Z<>
+
+There is no firewall
+
+=item 1Z<>
+
+     USER user@remote.host
+     PASS pass
+
+=item 2Z<>
+
+     USER fwuser
+     PASS fwpass
+     USER user@remote.host
+     PASS pass
+
+=item 3Z<>
+
+     USER fwuser
+     PASS fwpass
+     SITE remote.site
+     USER user
+     PASS pass
+
+=item 4Z<>
+
+     USER fwuser
+     PASS fwpass
+     OPEN remote.site
+     USER user
+     PASS pass
+
+=item 5Z<>
+
+     USER user@fwuser@remote.site
+     PASS pass@fwpass
+
+=item 6Z<>
+
+     USER fwuser@remote.site
+     PASS fwpass
+     USER user
+     PASS pass
+
+=item 7Z<>
+
+     USER user@remote.host
+     PASS pass
+     AUTH fwuser
+     RESP fwpass
+
+=back
+
+=item ftp_ext_passive
+
+=item ftp_int_passive
+
+FTP servers can work in passive or active mode. Active mode is when
+you want to transfer data you have to tell the server the address and
+port to connect to.  Passive mode is when the server provide the
+address and port and you establish the connection.
+
+With some firewalls active mode does not work as the server cannot
+connect to your machine (because you are behind a firewall) and the firewall
+does not re-write the command. In this case you should set C<ftp_ext_passive>
+to a I<true> value.
+
+Some servers are configured to only work in passive mode. If you have
+one of these you can force C<Net::FTP> to always transfer in passive
+mode; when not going via a firewall, by setting C<ftp_int_passive> to
+a I<true> value.
+
+=item local_netmask
+
+A reference to a list of netmask strings in the form C<"134.99.4.0/24">.
+These are used by the C<requires_firewall> function to determine if a given
+host is inside or outside your firewall.
+
+=back
+
+The following entries are used during installation & testing on the
+libnet package
+
+=over 4
+
+=item test_hosts
+
+If true then C<make test> may attempt to connect to hosts given in the
+configuration.
+
+=item test_exists
+
+If true then C<Configure> will check each hostname given that it exists
+
+=back
+
+=head1 EXPORTS
+
+The following symbols are, or can be, exported by this module:
+
+=over 4
+
+=item Default Exports
+
+C<%NetConfig>.
+
+=item Optional Exports
+
+I<None>.
+
+=item Export Tags
+
+I<None>.
+
+=back
+
+=head1 KNOWN BUGS
+
+I<None>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 2000 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2014, 2016, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/Domain.pm

@@ -0,0 +1,408 @@
+# Net::Domain.pm
+#
+# Copyright (C) 1995-1998 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2014, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::Domain;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Exporter;
+use Net::Config;
+
+our @ISA       = qw(Exporter);
+our @EXPORT_OK = qw(hostname hostdomain hostfqdn domainname);
+our $VERSION = "3.15";
+
+my ($host, $domain, $fqdn) = (undef, undef, undef);
+
+# Try every conceivable way to get hostname.
+
+
+sub _hostname {
+
+  # we already know it
+  return $host
+    if (defined $host);
+
+  if ($^O eq 'MSWin32') {
+    require Socket;
+    my ($name, $alias, $type, $len, @addr) = gethostbyname($ENV{'COMPUTERNAME'} || 'localhost');
+    while (@addr) {
+      my $a = shift(@addr);
+      $host = gethostbyaddr($a, Socket::AF_INET());
+      last if defined $host;
+    }
+    if (defined($host) && index($host, '.') > 0) {
+      $fqdn = $host;
+      ($host, $domain) = $fqdn =~ /^([^.]+)\.(.*)$/;
+    }
+    return $host;
+  }
+  elsif ($^O eq 'MacOS') {
+    chomp($host = `hostname`);
+  }
+  elsif ($^O eq 'VMS') {    ## multiple varieties of net s/w makes this hard
+    $host = $ENV{'UCX$INET_HOST'}      if defined($ENV{'UCX$INET_HOST'});
+    $host = $ENV{'MULTINET_HOST_NAME'} if defined($ENV{'MULTINET_HOST_NAME'});
+    if (index($host, '.') > 0) {
+      $fqdn = $host;
+      ($host, $domain) = $fqdn =~ /^([^.]+)\.(.*)$/;
+    }
+    return $host;
+  }
+  else {
+    local $SIG{'__DIE__'};
+
+    # syscall is preferred since it avoids tainting problems
+    eval {
+      my $tmp = "\0" x 256;    ## preload scalar
+      eval {
+        package main;
+        require "syscall.ph"; ## no critic (Modules::RequireBarewordIncludes)
+        defined(&main::SYS_gethostname);
+        }
+        || eval {
+        package main;
+        require "sys/syscall.ph"; ## no critic (Modules::RequireBarewordIncludes)
+        defined(&main::SYS_gethostname);
+        }
+        and $host =
+        (syscall(&main::SYS_gethostname, $tmp, 256) == 0)
+        ? $tmp
+        : undef;
+      }
+
+      # POSIX
+      || eval {
+      require POSIX;
+      $host = (POSIX::uname())[1];
+      }
+
+      # trusty old hostname command
+      || eval {
+      chop($host = `(hostname) 2>/dev/null`);    # BSD'ish
+      }
+
+      # sysV/POSIX uname command (may truncate)
+      || eval {
+      chop($host = `uname -n 2>/dev/null`);      ## SYSV'ish && POSIX'ish
+      }
+
+      # Apollo pre-SR10
+      || eval { $host = (split(/[:. ]/, `/com/host`, 6))[0]; }
+
+      || eval { $host = ""; };
+  }
+
+  # remove garbage
+  $host =~ s/[\0\r\n]+//go;
+  $host =~ s/(\A\.+|\.+\Z)//go;
+  $host =~ s/\.\.+/\./go;
+
+  $host;
+}
+
+
+sub _hostdomain {
+
+  # we already know it
+  return $domain
+    if (defined $domain);
+
+  local $SIG{'__DIE__'};
+
+  return $domain = $NetConfig{'inet_domain'}
+    if defined $NetConfig{'inet_domain'};
+
+  # try looking in /etc/resolv.conf
+  # putting this here and assuming that it is correct, eliminates
+  # calls to gethostbyname, and therefore DNS lookups. This helps
+  # those on dialup systems.
+
+  local ($_);
+
+  if (open(my $res, '<', "/etc/resolv.conf")) {
+    while (<$res>) {
+      $domain = $1
+        if (/\A\s*(?:domain|search)\s+(\S+)/);
+    }
+    close($res);
+
+    return $domain
+      if (defined $domain);
+  }
+
+  # just try hostname and system calls
+
+  my $host = _hostname();
+  my (@hosts);
+
+  @hosts = ($host, "localhost");
+
+  unless (defined($host) && $host =~ /\./) {
+    my $dom = undef;
+    eval {
+      my $tmp = "\0" x 256;    ## preload scalar
+      eval {
+        package main;
+        require "syscall.ph"; ## no critic (Modules::RequireBarewordIncludes)
+        }
+        || eval {
+        package main;
+        require "sys/syscall.ph"; ## no critic (Modules::RequireBarewordIncludes)
+        }
+        and $dom =
+        (syscall(&main::SYS_getdomainname, $tmp, 256) == 0)
+        ? $tmp
+        : undef;
+    };
+
+    if ($^O eq 'VMS') {
+      $dom ||= $ENV{'TCPIP$INET_DOMAIN'}
+        || $ENV{'UCX$INET_DOMAIN'};
+    }
+
+    chop($dom = `domainname 2>/dev/null`)
+      unless (defined $dom || $^O =~ /^(?:cygwin|MSWin32|android)/);
+
+    if (defined $dom) {
+      my @h = ();
+      $dom =~ s/^\.+//;
+      while (length($dom)) {
+        push(@h, "$host.$dom");
+        $dom =~ s/^[^.]+.+// or last;
+      }
+      unshift(@hosts, @h);
+    }
+  }
+
+  # Attempt to locate FQDN
+
+  foreach (grep { defined $_ } @hosts) {
+    my @info = gethostbyname($_);
+
+    next unless @info;
+
+    # look at real name & aliases
+    foreach my $site ($info[0], split(/ /, $info[1])) {
+      if (rindex($site, ".") > 0) {
+
+        # Extract domain from FQDN
+
+        ($domain = $site) =~ s/\A[^.]+\.//;
+        return $domain;
+      }
+    }
+  }
+
+  # Look for environment variable
+
+  $domain ||= $ENV{LOCALDOMAIN} || $ENV{DOMAIN};
+
+  if (defined $domain) {
+    $domain =~ s/[\r\n\0]+//g;
+    $domain =~ s/(\A\.+|\.+\Z)//g;
+    $domain =~ s/\.\.+/\./g;
+  }
+
+  $domain;
+}
+
+
+sub domainname {
+
+  return $fqdn
+    if (defined $fqdn);
+
+  _hostname();
+
+  # *.local names are special on darwin. If we call gethostbyname below, it
+  # may hang while waiting for another, non-existent computer to respond.
+  if($^O eq 'darwin' && $host =~ /\.local$/) {
+    return $host;
+  }
+
+  _hostdomain();
+
+  # Assumption: If the host name does not contain a period
+  # and the domain name does, then assume that they are correct
+  # this helps to eliminate calls to gethostbyname, and therefore
+  # eliminate DNS lookups
+
+  return $fqdn = $host . "." . $domain
+    if (defined $host
+    and defined $domain
+    and $host !~ /\./
+    and $domain =~ /\./);
+
+  # For hosts that have no name, just an IP address
+  return $fqdn = $host if defined $host and $host =~ /^\d+(\.\d+){3}$/;
+
+  my @host   = defined $host   ? split(/\./, $host)   : ('localhost');
+  my @domain = defined $domain ? split(/\./, $domain) : ();
+  my @fqdn   = ();
+
+  # Determine from @host & @domain the FQDN
+
+  my @d = @domain;
+
+LOOP:
+  while (1) {
+    my @h = @host;
+    while (@h) {
+      my $tmp = join(".", @h, @d);
+      if ((gethostbyname($tmp))[0]) {
+        @fqdn = (@h, @d);
+        $fqdn = $tmp;
+        last LOOP;
+      }
+      pop @h;
+    }
+    last unless shift @d;
+  }
+
+  if (@fqdn) {
+    $host = shift @fqdn;
+    until ((gethostbyname($host))[0]) {
+      $host .= "." . shift @fqdn;
+    }
+    $domain = join(".", @fqdn);
+  }
+  else {
+    undef $host;
+    undef $domain;
+    undef $fqdn;
+  }
+
+  $fqdn;
+}
+
+
+sub hostfqdn { domainname() }
+
+
+sub hostname {
+  domainname()
+    unless (defined $host);
+  return $host;
+}
+
+
+sub hostdomain {
+  domainname()
+    unless (defined $domain);
+  return $domain;
+}
+
+1;    # Keep require happy
+
+__END__
+
+=head1 NAME
+
+Net::Domain - Attempt to evaluate the current host's internet name and domain
+
+=head1 SYNOPSIS
+
+    use Net::Domain qw(hostname hostfqdn hostdomain domainname);
+
+=head1 DESCRIPTION
+
+Using various methods B<attempt> to find the Fully Qualified Domain Name (FQDN)
+of the current host. From this determine the host-name and the host-domain.
+
+Each of the functions will return I<undef> if the FQDN cannot be determined.
+
+=head2 Functions
+
+=over 4
+
+=item C<hostfqdn()>
+
+Identify and return the FQDN of the current host.
+
+=item C<domainname()>
+
+An alias for hostfqdn().
+
+=item C<hostname()>
+
+Returns the smallest part of the FQDN which can be used to identify the host.
+
+=item C<hostdomain()>
+
+Returns the remainder of the FQDN after the I<hostname> has been removed.
+
+=back
+
+=head1 EXPORTS
+
+The following symbols are, or can be, exported by this module:
+
+=over 4
+
+=item Default Exports
+
+I<None>.
+
+=item Optional Exports
+
+C<hostname>,
+C<hostdomain>,
+C<hostfqdn>,
+C<domainname>.
+
+=item Export Tags
+
+I<None>.
+
+=back
+
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Adapted from Sys::Hostname by David Sundstrom
+E<lt>L<sunds@asictest.sc.ti.com|mailto:sunds@asictest.sc.ti.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-1998 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2014, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/FTP.pm

@@ -0,0 +1,2037 @@
+# Net::FTP.pm
+#
+# Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2017, 2020, 2022 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+#
+# Documentation (at end) improved 1996 by Nathan Torkington <gnat@frii.com>.
+
+package Net::FTP;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Fcntl qw(O_WRONLY O_RDONLY O_APPEND O_CREAT O_TRUNC);
+use IO::Socket;
+use Net::Cmd;
+use Net::Config;
+use Socket;
+use Time::Local;
+
+our $VERSION = '3.15';
+
+our $IOCLASS;
+my $family_key;
+BEGIN {
+  # Code for detecting if we can use SSL
+  my $ssl_class = eval {
+    require IO::Socket::SSL;
+    # first version with default CA on most platforms
+    no warnings 'numeric';
+    IO::Socket::SSL->VERSION(2.007);
+  } && 'IO::Socket::SSL';
+
+  my $nossl_warn = !$ssl_class &&
+    'To use SSL please install IO::Socket::SSL with version>=2.007';
+
+  # Code for detecting if we can use IPv6
+  my $inet6_class = eval {
+    require IO::Socket::IP;
+    no warnings 'numeric';
+    IO::Socket::IP->VERSION(0.25);
+  } && 'IO::Socket::IP' || eval {
+    require IO::Socket::INET6;
+    no warnings 'numeric';
+    IO::Socket::INET6->VERSION(2.62);
+  } && 'IO::Socket::INET6';
+
+  sub can_ssl   { $ssl_class };
+  sub can_inet6 { $inet6_class };
+
+  $IOCLASS = $ssl_class || $inet6_class || 'IO::Socket::INET';
+  $family_key =
+    ( $ssl_class ? $ssl_class->can_ipv6 : $inet6_class || '' )
+      eq 'IO::Socket::IP'
+      ? 'Family' : 'Domain';
+}
+
+our @ISA = ('Exporter','Net::Cmd',$IOCLASS);
+
+use constant TELNET_IAC => 255;
+use constant TELNET_IP  => 244;
+use constant TELNET_DM  => 242;
+
+use constant EBCDIC => ord 'A' == 193;
+
+sub new {
+  my $pkg = shift;
+  my ($peer, %arg);
+  if (@_ % 2) {
+    $peer = shift;
+    %arg  = @_;
+  }
+  else {
+    %arg  = @_;
+    $peer = delete $arg{Host};
+  }
+
+  my $host      = $peer;
+  my $fire      = undef;
+  my $fire_type = undef;
+
+  if (exists($arg{Firewall}) || Net::Config->requires_firewall($peer)) {
+         $fire = $arg{Firewall}
+      || $ENV{FTP_FIREWALL}
+      || $NetConfig{ftp_firewall}
+      || undef;
+
+    if (defined $fire) {
+      $peer = $fire;
+      delete $arg{Port};
+           $fire_type = $arg{FirewallType}
+        || $ENV{FTP_FIREWALL_TYPE}
+        || $NetConfig{firewall_type}
+        || undef;
+    }
+  }
+
+  my %tlsargs;
+  if (can_ssl()) {
+    # for name verification strip port from domain:port, ipv4:port, [ipv6]:port
+    (my $hostname = $host) =~s{(?<!:):\d+$}{};
+    %tlsargs = (
+      SSL_verifycn_scheme => 'ftp',
+      SSL_verifycn_name => $hostname,
+      # use SNI if supported by IO::Socket::SSL
+      $pkg->can_client_sni ? (SSL_hostname => $hostname):(),
+      # reuse SSL session of control connection in data connections
+      SSL_session_cache_size => 10,
+      SSL_session_key => $hostname,
+    );
+    # user defined SSL arg
+    $tlsargs{$_} = $arg{$_} for(grep { m{^SSL_} } keys %arg);
+    $tlsargs{SSL_reuse_ctx} = IO::Socket::SSL::SSL_Context->new(%tlsargs)
+      or return;
+
+  } elsif ($arg{SSL}) {
+    croak("IO::Socket::SSL >= 2.007 needed for SSL support");
+  }
+
+  my $ftp = $pkg->SUPER::new(
+    PeerAddr  => $peer,
+    PeerPort  => $arg{Port} || ($arg{SSL} ? 'ftps(990)' : 'ftp(21)'),
+    LocalAddr => $arg{'LocalAddr'},
+    $family_key => $arg{Domain} || $arg{Family},
+    Proto     => 'tcp',
+    Timeout   => defined $arg{Timeout} ? $arg{Timeout} : 120,
+    %tlsargs,
+    $arg{SSL} ? ():( SSL_startHandshake => 0 ),
+  ) or return;
+
+  ${*$ftp}{'net_ftp_host'}    = $host;                             # Remote hostname
+  ${*$ftp}{'net_ftp_type'}    = 'A';                               # ASCII/binary/etc mode
+  ${*$ftp}{'net_ftp_blksize'} = abs($arg{'BlockSize'} || 10240);
+
+  ${*$ftp}{'net_ftp_localaddr'} = $arg{'LocalAddr'};
+  ${*$ftp}{'net_ftp_domain'} = $arg{Domain} || $arg{Family};
+
+  ${*$ftp}{'net_ftp_firewall'} = $fire
+    if (defined $fire);
+  ${*$ftp}{'net_ftp_firewall_type'} = $fire_type
+    if (defined $fire_type);
+
+  ${*$ftp}{'net_ftp_passive'} =
+      int exists $arg{Passive} ? $arg{Passive}
+    : exists $ENV{FTP_PASSIVE} ? $ENV{FTP_PASSIVE}
+    : defined $fire            ? $NetConfig{ftp_ext_passive}
+    : $NetConfig{ftp_int_passive};    # Whew! :-)
+
+  ${*$ftp}{net_ftp_tlsargs} = \%tlsargs if %tlsargs;
+  if ($arg{SSL}) {
+    ${*$ftp}{net_ftp_tlsprot} = 'P';
+    ${*$ftp}{net_ftp_tlsdirect} = 1;
+  }
+
+  $ftp->hash(exists $arg{Hash} ? $arg{Hash} : 0, 1024);
+
+  $ftp->autoflush(1);
+
+  $ftp->debug(exists $arg{Debug} ? $arg{Debug} : undef);
+
+  unless ($ftp->response() == CMD_OK) {
+    $ftp->close();
+    # keep @$ if no message. Happens, when response did not start with a code.
+    $@ = $ftp->message || $@;
+    undef $ftp;
+  }
+
+  $ftp;
+}
+
+##
+## User interface methods
+##
+
+
+sub host {
+  my $me = shift;
+  ${*$me}{'net_ftp_host'};
+}
+
+sub passive {
+  my $ftp = shift;
+  return ${*$ftp}{'net_ftp_passive'} unless @_;
+  ${*$ftp}{'net_ftp_passive'} = shift;
+}
+
+
+sub hash {
+  my $ftp = shift;    # self
+
+  my ($h, $b) = @_;
+  unless ($h) {
+    delete ${*$ftp}{'net_ftp_hash'};
+    return [\*STDERR, 0];
+  }
+  ($h, $b) = (ref($h) ? $h : \*STDERR, $b || 1024);
+  select((select($h), $| = 1)[0]);
+  $b = 512 if $b < 512;
+  ${*$ftp}{'net_ftp_hash'} = [$h, $b];
+}
+
+
+sub quit {
+  my $ftp = shift;
+
+  $ftp->_QUIT;
+  $ftp->close;
+}
+
+
+sub DESTROY { }
+
+
+sub ascii  { shift->type('A', @_); }
+sub binary { shift->type('I', @_); }
+
+
+sub ebcdic {
+  carp "TYPE E is unsupported, shall default to I";
+  shift->type('E', @_);
+}
+
+
+sub byte {
+  carp "TYPE L is unsupported, shall default to I";
+  shift->type('L', @_);
+}
+
+# Allow the user to send a command directly, BE CAREFUL !!
+
+
+sub quot {
+  my $ftp = shift;
+  my $cmd = shift;
+
+  $ftp->command(uc $cmd, @_);
+  $ftp->response();
+}
+
+
+sub site {
+  my $ftp = shift;
+
+  $ftp->command("SITE", @_);
+  $ftp->response();
+}
+
+
+sub mdtm {
+  my $ftp  = shift;
+  my $file = shift;
+
+  # Server Y2K bug workaround
+  #
+  # sigh; some idiotic FTP servers use ("19%d",tm.tm_year) instead of
+  # ("%d",tm.tm_year+1900).  This results in an extra digit in the
+  # string returned. To account for this we allow an optional extra
+  # digit in the year. Then if the first two digits are 19 we use the
+  # remainder, otherwise we subtract 1900 from the whole year.
+
+  $ftp->_MDTM($file)
+    && $ftp->message =~ /((\d\d)(\d\d\d?))(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/
+    ? timegm($8, $7, $6, $5, $4 - 1, $2 eq '19' ? ($3 + 1900) : $1)
+    : undef;
+}
+
+
+sub size {
+  my $ftp  = shift;
+  my $file = shift;
+  my $io;
+  if ($ftp->supported("SIZE")) {
+    return $ftp->_SIZE($file)
+      ? ($ftp->message =~ /(\d+)\s*(bytes?\s*)?$/)[0]
+      : undef;
+  }
+  elsif ($ftp->supported("STAT")) {
+    my @msg;
+    return
+      unless $ftp->_STAT($file) && (@msg = $ftp->message) == 3;
+    foreach my $line (@msg) {
+      return (split(/\s+/, $line))[4]
+        if $line =~ /^[-rwxSsTt]{10}/;
+    }
+  }
+  else {
+    my @files = $ftp->dir($file);
+    if (@files) {
+      return (split(/\s+/, $1))[4]
+        if $files[0] =~ /^([-rwxSsTt]{10}.*)$/;
+    }
+  }
+  undef;
+}
+
+
+sub starttls {
+  my $ftp = shift;
+  can_ssl() or croak("IO::Socket::SSL >= 2.007 needed for SSL support");
+  $ftp->is_SSL and croak("called starttls within SSL session");
+  $ftp->_AUTH('TLS') == CMD_OK or return;
+
+  $ftp->connect_SSL or return;
+  $ftp->prot('P');
+  return 1;
+}
+
+sub prot {
+  my ($ftp,$prot) = @_;
+  $prot eq 'C' or $prot eq 'P' or croak("prot must by C or P");
+  $ftp->_PBSZ(0) or return;
+  $ftp->_PROT($prot) or return;
+  ${*$ftp}{net_ftp_tlsprot} = $prot;
+  return 1;
+}
+
+sub stoptls {
+  my $ftp = shift;
+  $ftp->is_SSL or croak("called stoptls outside SSL session");
+  ${*$ftp}{net_ftp_tlsdirect} and croak("cannot stoptls direct SSL session");
+  $ftp->_CCC() or return;
+  $ftp->stop_SSL();
+  return 1;
+}
+
+sub login {
+  my ($ftp, $user, $pass, $acct) = @_;
+  my ($ok, $ruser, $fwtype);
+
+  unless (defined $user) {
+    require Net::Netrc;
+
+    my $rc = Net::Netrc->lookup(${*$ftp}{'net_ftp_host'});
+
+    ($user, $pass, $acct) = $rc->lpa()
+      if ($rc);
+  }
+
+  $user ||= "anonymous";
+  $ruser = $user;
+
+  $fwtype = ${*$ftp}{'net_ftp_firewall_type'}
+    || $NetConfig{'ftp_firewall_type'}
+    || 0;
+
+  if ($fwtype && defined ${*$ftp}{'net_ftp_firewall'}) {
+    if ($fwtype == 1 || $fwtype == 7) {
+      $user .= '@' . ${*$ftp}{'net_ftp_host'};
+    }
+    else {
+      require Net::Netrc;
+
+      my $rc = Net::Netrc->lookup(${*$ftp}{'net_ftp_firewall'});
+
+      my ($fwuser, $fwpass, $fwacct) = $rc ? $rc->lpa() : ();
+
+      if ($fwtype == 5) {
+        $user = join('@', $user, $fwuser, ${*$ftp}{'net_ftp_host'});
+        $pass = $pass . '@' . $fwpass;
+      }
+      else {
+        if ($fwtype == 2) {
+          $user .= '@' . ${*$ftp}{'net_ftp_host'};
+        }
+        elsif ($fwtype == 6) {
+          $fwuser .= '@' . ${*$ftp}{'net_ftp_host'};
+        }
+
+        $ok = $ftp->_USER($fwuser);
+
+        return 0 unless $ok == CMD_OK || $ok == CMD_MORE;
+
+        $ok = $ftp->_PASS($fwpass || "");
+
+        return 0 unless $ok == CMD_OK || $ok == CMD_MORE;
+
+        $ok = $ftp->_ACCT($fwacct)
+          if defined($fwacct);
+
+        if ($fwtype == 3) {
+          $ok = $ftp->command("SITE", ${*$ftp}{'net_ftp_host'})->response;
+        }
+        elsif ($fwtype == 4) {
+          $ok = $ftp->command("OPEN", ${*$ftp}{'net_ftp_host'})->response;
+        }
+
+        return 0 unless $ok == CMD_OK || $ok == CMD_MORE;
+      }
+    }
+  }
+
+  $ok = $ftp->_USER($user);
+
+  # Some dumb firewalls don't prefix the connection messages
+  $ok = $ftp->response()
+    if ($ok == CMD_OK && $ftp->code == 220 && $user =~ /\@/);
+
+  if ($ok == CMD_MORE) {
+    unless (defined $pass) {
+      require Net::Netrc;
+
+      my $rc = Net::Netrc->lookup(${*$ftp}{'net_ftp_host'}, $ruser);
+
+      ($ruser, $pass, $acct) = $rc->lpa()
+        if ($rc);
+
+      $pass = '-anonymous@'
+        if (!defined $pass && (!defined($ruser) || $ruser =~ /^anonymous/o));
+    }
+
+    $ok = $ftp->_PASS($pass || "");
+  }
+
+  $ok = $ftp->_ACCT($acct)
+    if (defined($acct) && ($ok == CMD_MORE || $ok == CMD_OK));
+
+  if ($fwtype == 7 && $ok == CMD_OK && defined ${*$ftp}{'net_ftp_firewall'}) {
+    my ($f, $auth, $resp) = _auth_id($ftp);
+    $ftp->authorize($auth, $resp) if defined($resp);
+  }
+
+  $ok == CMD_OK;
+}
+
+
+sub account {
+  @_ == 2 or croak 'usage: $ftp->account($acct)';
+  my $ftp  = shift;
+  my $acct = shift;
+  $ftp->_ACCT($acct) == CMD_OK;
+}
+
+
+sub _auth_id {
+  my ($ftp, $auth, $resp) = @_;
+
+  unless (defined $resp) {
+    require Net::Netrc;
+
+    $auth ||= eval { (getpwuid($>))[0] } || $ENV{NAME};
+
+    my $rc = Net::Netrc->lookup(${*$ftp}{'net_ftp_firewall'}, $auth)
+      || Net::Netrc->lookup(${*$ftp}{'net_ftp_firewall'});
+
+    ($auth, $resp) = $rc->lpa()
+      if ($rc);
+  }
+  ($ftp, $auth, $resp);
+}
+
+
+sub authorize {
+  @_ >= 1 || @_ <= 3 or croak 'usage: $ftp->authorize([$auth[, $resp]])';
+
+  my ($ftp, $auth, $resp) = &_auth_id;
+
+  my $ok = $ftp->_AUTH($auth || "");
+
+  return $ftp->_RESP($resp || "")
+    if ($ok == CMD_MORE);
+
+  $ok == CMD_OK;
+}
+
+
+sub rename {
+  @_ == 3 or croak 'usage: $ftp->rename($oldname, $newname)';
+
+  my ($ftp, $oldname, $newname) = @_;
+
+  $ftp->_RNFR($oldname)
+    && $ftp->_RNTO($newname);
+}
+
+
+sub type {
+  my $ftp    = shift;
+  my $type   = shift;
+  my $oldval = ${*$ftp}{'net_ftp_type'};
+
+  return $oldval
+    unless (defined $type);
+
+  return
+    unless ($ftp->_TYPE($type, @_));
+
+  ${*$ftp}{'net_ftp_type'} = join(" ", $type, @_);
+
+  $oldval;
+}
+
+
+sub alloc {
+  my $ftp    = shift;
+  my $size   = shift;
+  my $oldval = ${*$ftp}{'net_ftp_allo'};
+
+  return $oldval
+    unless (defined $size);
+
+  return
+    unless ($ftp->supported("ALLO") and $ftp->_ALLO($size, @_));
+
+  ${*$ftp}{'net_ftp_allo'} = join(" ", $size, @_);
+
+  $oldval;
+}
+
+
+sub abort {
+  my $ftp = shift;
+
+  send($ftp, pack("CCC", TELNET_IAC, TELNET_IP, TELNET_IAC), MSG_OOB);
+
+  $ftp->command(pack("C", TELNET_DM) . "ABOR");
+
+  ${*$ftp}{'net_ftp_dataconn'}->close()
+    if defined ${*$ftp}{'net_ftp_dataconn'};
+
+  $ftp->response();
+
+  $ftp->status == CMD_OK;
+}
+
+
+sub get {
+  my ($ftp, $remote, $local, $where) = @_;
+
+  my ($loc, $len, $buf, $resp, $data);
+  local *FD;
+
+  my $localfd = ref($local) || ref(\$local) eq "GLOB";
+
+  ($local = $remote) =~ s#^.*/##
+    unless (defined $local);
+
+  croak("Bad remote filename '$remote'\n")
+    if $remote =~ /[\r\n]/s;
+
+  ${*$ftp}{'net_ftp_rest'} = $where if defined $where;
+  my $rest = ${*$ftp}{'net_ftp_rest'};
+
+  delete ${*$ftp}{'net_ftp_port'};
+  delete ${*$ftp}{'net_ftp_pasv'};
+
+  $data = $ftp->retr($remote)
+    or return;
+
+  if ($localfd) {
+    $loc = $local;
+  }
+  else {
+    $loc = \*FD;
+
+    unless (sysopen($loc, $local, O_CREAT | O_WRONLY | ($rest ? O_APPEND: O_TRUNC))) {
+      carp "Cannot open Local file $local: $!\n";
+      $data->abort;
+      return;
+    }
+  }
+
+  if ($ftp->type eq 'I' && !binmode($loc)) {
+    carp "Cannot binmode Local file $local: $!\n";
+    $data->abort;
+    close($loc) unless $localfd;
+    return;
+  }
+
+  $buf = '';
+  my ($count, $hashh, $hashb, $ref) = (0);
+
+  ($hashh, $hashb) = @$ref
+    if ($ref = ${*$ftp}{'net_ftp_hash'});
+
+  my $blksize = ${*$ftp}{'net_ftp_blksize'};
+  local $\;    # Just in case
+
+  while (1) {
+    last unless $len = $data->read($buf, $blksize);
+
+    if (EBCDIC && $ftp->type ne 'I') {
+      $buf = $ftp->toebcdic($buf);
+      $len = length($buf);
+    }
+
+    if ($hashh) {
+      $count += $len;
+      print $hashh "#" x (int($count / $hashb));
+      $count %= $hashb;
+    }
+    unless (print $loc $buf) {
+      carp "Cannot write to Local file $local: $!\n";
+      $data->abort;
+      close($loc)
+        unless $localfd;
+      return;
+    }
+  }
+
+  print $hashh "\n" if $hashh;
+
+  unless ($localfd) {
+    unless (close($loc)) {
+      carp "Cannot close file $local (perhaps disk space) $!\n";
+      return;
+    }
+  }
+
+  unless ($data->close())    # implied $ftp->response
+  {
+    carp "Unable to close datastream";
+    return;
+  }
+
+  return $local;
+}
+
+
+sub cwd {
+  @_ == 1 || @_ == 2 or croak 'usage: $ftp->cwd([$dir])';
+
+  my ($ftp, $dir) = @_;
+
+  $dir = "/" unless defined($dir) && $dir =~ /\S/;
+
+  $dir eq ".."
+    ? $ftp->_CDUP()
+    : $ftp->_CWD($dir);
+}
+
+
+sub cdup {
+  @_ == 1 or croak 'usage: $ftp->cdup()';
+  $_[0]->_CDUP;
+}
+
+
+sub pwd {
+  @_ == 1 || croak 'usage: $ftp->pwd()';
+  my $ftp = shift;
+
+  $ftp->_PWD();
+  $ftp->_extract_path;
+}
+
+# rmdir( $ftp, $dir, [ $recurse ] )
+#
+# Removes $dir on remote host via FTP.
+# $ftp is handle for remote host
+#
+# If $recurse is TRUE, the directory and deleted recursively.
+# This means all of its contents and subdirectories.
+#
+# Initial version contributed by Dinkum Software
+#
+sub rmdir {
+  @_ == 2 || @_ == 3 or croak('usage: $ftp->rmdir($dir[, $recurse])');
+
+  # Pick off the args
+  my ($ftp, $dir, $recurse) = @_;
+  my $ok;
+
+  return $ok
+    if $ok = $ftp->_RMD($dir)
+    or !$recurse;
+
+  # Try to delete the contents
+  # Get a list of all the files in the directory, excluding the current and parent directories
+  my @filelist = map { /^(?:\S+;)+ (.+)$/ ? ($1) : () } grep { !/^(?:\S+;)*type=[cp]dir;/i } $ftp->_list_cmd("MLSD", $dir);
+
+  # Fallback to using the less well-defined NLST command if MLSD fails
+  @filelist = grep { !/^\.{1,2}$/ } $ftp->ls($dir)
+    unless @filelist;
+
+  return
+    unless @filelist;    # failed, it is probably not a directory
+
+  return $ftp->delete($dir)
+    if @filelist == 1 and $dir eq $filelist[0];
+
+  # Go thru and delete each file or the directory
+  foreach my $file (map { m,/, ? $_ : "$dir/$_" } @filelist) {
+    next                 # successfully deleted the file
+      if $ftp->delete($file);
+
+    # Failed to delete it, assume its a directory
+    # Recurse and ignore errors, the final rmdir() will
+    # fail on any errors here
+    return $ok
+      unless $ok = $ftp->rmdir($file, 1);
+  }
+
+  # Directory should be empty
+  # Try to remove the directory again
+  # Pass results directly to caller
+  # If any of the prior deletes failed, this
+  # rmdir() will fail because directory is not empty
+  return $ftp->_RMD($dir);
+}
+
+
+sub restart {
+  @_ == 2 || croak 'usage: $ftp->restart($where)';
+
+  my ($ftp, $where) = @_;
+
+  ${*$ftp}{'net_ftp_rest'} = $where;
+
+  return;
+}
+
+
+sub mkdir {
+  @_ == 2 || @_ == 3 or croak 'usage: $ftp->mkdir($dir[, $recurse])';
+
+  my ($ftp, $dir, $recurse) = @_;
+
+  $ftp->_MKD($dir) || $recurse
+    or return;
+
+  my $path = $dir;
+
+  unless ($ftp->ok) {
+    my @path = split(m#(?=/+)#, $dir);
+
+    $path = "";
+
+    while (@path) {
+      $path .= shift @path;
+
+      $ftp->_MKD($path);
+
+      $path = $ftp->_extract_path($path);
+    }
+
+    # If the creation of the last element was not successful, see if we
+    # can cd to it, if so then return path
+
+    unless ($ftp->ok) {
+      my ($status, $message) = ($ftp->status, $ftp->message);
+      my $pwd = $ftp->pwd;
+
+      if ($pwd && $ftp->cwd($dir)) {
+        $path = $dir;
+        $ftp->cwd($pwd);
+      }
+      else {
+        undef $path;
+      }
+      $ftp->set_status($status, $message);
+    }
+  }
+
+  $path;
+}
+
+
+sub delete {
+  @_ == 2 || croak 'usage: $ftp->delete($filename)';
+
+  $_[0]->_DELE($_[1]);
+}
+
+
+sub put        { shift->_store_cmd("stor", @_) }
+sub put_unique { shift->_store_cmd("stou", @_) }
+sub append     { shift->_store_cmd("appe", @_) }
+
+
+sub nlst { shift->_data_cmd("NLST", @_) }
+sub list { shift->_data_cmd("LIST", @_) }
+sub retr { shift->_data_cmd("RETR", @_) }
+sub stor { shift->_data_cmd("STOR", @_) }
+sub stou { shift->_data_cmd("STOU", @_) }
+sub appe { shift->_data_cmd("APPE", @_) }
+
+
+sub _store_cmd {
+  my ($ftp, $cmd, $local, $remote) = @_;
+  my ($loc, $sock, $len, $buf);
+  local *FD;
+
+  my $localfd = ref($local) || ref(\$local) eq "GLOB";
+
+  if (!defined($remote) and 'STOU' ne uc($cmd)) {
+    croak 'Must specify remote filename with stream input'
+      if $localfd;
+
+    require File::Basename;
+    $remote = File::Basename::basename($local);
+  }
+  if (defined ${*$ftp}{'net_ftp_allo'}) {
+    delete ${*$ftp}{'net_ftp_allo'};
+  }
+  else {
+
+    # if the user hasn't already invoked the alloc method since the last
+    # _store_cmd call, figure out if the local file is a regular file(not
+    # a pipe, or device) and if so get the file size from stat, and send
+    # an ALLO command before sending the STOR, STOU, or APPE command.
+    my $size = do { local $^W; -f $local && -s _ };    # no ALLO if sending data from a pipe
+    ${*$ftp}{'net_ftp_allo'} = $size if $size;
+  }
+  croak("Bad remote filename '$remote'\n")
+    if defined($remote) and $remote =~ /[\r\n]/s;
+
+  if ($localfd) {
+    $loc = $local;
+  }
+  else {
+    $loc = \*FD;
+
+    unless (sysopen($loc, $local, O_RDONLY)) {
+      carp "Cannot open Local file $local: $!\n";
+      return;
+    }
+  }
+
+  if ($ftp->type eq 'I' && !binmode($loc)) {
+    carp "Cannot binmode Local file $local: $!\n";
+    return;
+  }
+
+  delete ${*$ftp}{'net_ftp_port'};
+  delete ${*$ftp}{'net_ftp_pasv'};
+
+  $sock = $ftp->_data_cmd($cmd, grep { defined } $remote)
+    or return;
+
+  $remote = ($ftp->message =~ /\w+\s*:\s*(.*)/)[0]
+    if 'STOU' eq uc $cmd;
+
+  my $blksize = ${*$ftp}{'net_ftp_blksize'};
+
+  my ($count, $hashh, $hashb, $ref) = (0);
+
+  ($hashh, $hashb) = @$ref
+    if ($ref = ${*$ftp}{'net_ftp_hash'});
+
+  while (1) {
+    last unless $len = read($loc, $buf = "", $blksize);
+
+    if (EBCDIC && $ftp->type ne 'I') {
+      $buf = $ftp->toascii($buf);
+      $len = length($buf);
+    }
+
+    if ($hashh) {
+      $count += $len;
+      print $hashh "#" x (int($count / $hashb));
+      $count %= $hashb;
+    }
+
+    my $wlen;
+    unless (defined($wlen = $sock->write($buf, $len)) && $wlen == $len) {
+      $sock->abort;
+      close($loc)
+        unless $localfd;
+      print $hashh "\n" if $hashh;
+      return;
+    }
+  }
+
+  print $hashh "\n" if $hashh;
+
+  close($loc)
+    unless $localfd;
+
+  $sock->close()
+    or return;
+
+  if ('STOU' eq uc $cmd and $ftp->message =~ m/unique\s+file\s*name\s*:\s*(.*)\)|"(.*)"/) {
+    require File::Basename;
+    $remote = File::Basename::basename($+);
+  }
+
+  return $remote;
+}
+
+
+sub port {
+    @_ == 1 || @_ == 2 or croak 'usage: $self->port([$port])';
+    return _eprt('PORT',@_);
+}
+
+sub eprt {
+  @_ == 1 || @_ == 2 or croak 'usage: $self->eprt([$port])';
+  return _eprt('EPRT',@_);
+}
+
+sub _eprt {
+  my ($cmd,$ftp,$port) = @_;
+  delete ${*$ftp}{net_ftp_intern_port};
+  unless ($port) {
+    my $listen = ${*$ftp}{net_ftp_listen} ||= $IOCLASS->new(
+      Listen    => 1,
+      Timeout   => $ftp->timeout,
+      LocalAddr => $ftp->sockhost,
+      $family_key  => $ftp->sockdomain,
+      can_ssl() ? (
+        %{ ${*$ftp}{net_ftp_tlsargs} },
+        SSL_startHandshake => 0,
+      ):(),
+    );
+    ${*$ftp}{net_ftp_intern_port} = 1;
+    my $fam = ($listen->sockdomain == AF_INET) ? 1:2;
+    if ( $cmd eq 'EPRT' || $fam == 2 ) {
+      $port = "|$fam|".$listen->sockhost."|".$listen->sockport."|";
+      $cmd = 'EPRT';
+    } else {
+      my $p = $listen->sockport;
+      $port = join(',',split(m{\.},$listen->sockhost),$p >> 8,$p & 0xff);
+    }
+  } elsif (ref($port) eq 'ARRAY') {
+    $port = join(',',split(m{\.},@$port[0]),@$port[1] >> 8,@$port[1] & 0xff);
+  }
+  my $ok = $cmd eq 'EPRT' ? $ftp->_EPRT($port) : $ftp->_PORT($port);
+  ${*$ftp}{net_ftp_port} = $port if $ok;
+  return $ok;
+}
+
+
+sub ls  { shift->_list_cmd("NLST", @_); }
+sub dir { shift->_list_cmd("LIST", @_); }
+
+
+sub pasv {
+  my $ftp = shift;
+  @_ and croak 'usage: $ftp->port()';
+  return $ftp->epsv if $ftp->sockdomain != AF_INET;
+  delete ${*$ftp}{net_ftp_intern_port};
+
+  if ( $ftp->_PASV &&
+    $ftp->message =~ m{(\d+,\d+,\d+,\d+),(\d+),(\d+)} ) {
+    my $port = 256 * $2 + $3;
+    ( my $ip = $1 ) =~s{,}{.}g;
+    return ${*$ftp}{net_ftp_pasv} = [ $ip,$port ];
+  }
+  return;
+}
+
+sub epsv {
+  my $ftp = shift;
+  @_ and croak 'usage: $ftp->epsv()';
+  delete ${*$ftp}{net_ftp_intern_port};
+
+  $ftp->_EPSV && $ftp->message =~ m{\(([\x33-\x7e])\1\1(\d+)\1\)}
+    ? ${*$ftp}{net_ftp_pasv} = [ $ftp->peerhost, $2 ]
+    : undef;
+}
+
+
+sub unique_name {
+  my $ftp = shift;
+  ${*$ftp}{'net_ftp_unique'} || undef;
+}
+
+
+sub supported {
+  @_ == 2 or croak 'usage: $ftp->supported($cmd)';
+  my $ftp  = shift;
+  my $cmd  = uc shift;
+  my $hash = ${*$ftp}{'net_ftp_supported'} ||= {};
+
+  return $hash->{$cmd}
+    if exists $hash->{$cmd};
+
+  return $hash->{$cmd} = 1
+    if $ftp->feature($cmd);
+
+  return $hash->{$cmd} = 0
+    unless $ftp->_HELP($cmd);
+
+  my $text = $ftp->message;
+  if ($text =~ /following.+commands/i) {
+    $text =~ s/^.*\n//;
+    while ($text =~ /(\*?)(\w+)(\*?)/sg) {
+      $hash->{"\U$2"} = !length("$1$3");
+    }
+  }
+  else {
+    $hash->{$cmd} = $text !~ /unimplemented/i;
+  }
+
+  $hash->{$cmd} ||= 0;
+}
+
+##
+## Deprecated methods
+##
+
+
+sub lsl {
+  carp "Use of Net::FTP::lsl deprecated, use 'dir'"
+    if $^W;
+  goto &dir;
+}
+
+
+sub authorise {
+  carp "Use of Net::FTP::authorise deprecated, use 'authorize'"
+    if $^W;
+  goto &authorize;
+}
+
+
+##
+## Private methods
+##
+
+
+sub _extract_path {
+  my ($ftp, $path) = @_;
+
+  # This tries to work both with and without the quote doubling
+  # convention (RFC 959 requires it, but the first 3 servers I checked
+  # didn't implement it).  It will fail on a server which uses a quote in
+  # the message which isn't a part of or surrounding the path.
+  $ftp->ok
+    && $ftp->message =~ /(?:^|\s)\"(.*)\"(?:$|\s)/
+    && ($path = $1) =~ s/\"\"/\"/g;
+
+  $path;
+}
+
+##
+## Communication methods
+##
+
+
+sub _dataconn {
+  my $ftp = shift;
+  my $pkg = "Net::FTP::" . $ftp->type;
+  eval "require " . $pkg ## no critic (BuiltinFunctions::ProhibitStringyEval)
+    or croak("cannot load $pkg required for type ".$ftp->type);
+  $pkg =~ s/ /_/g;
+  delete ${*$ftp}{net_ftp_dataconn};
+
+  my $conn;
+  my $pasv = ${*$ftp}{net_ftp_pasv};
+  if ($pasv) {
+    $conn = $pkg->new(
+      PeerAddr  => $pasv->[0],
+      PeerPort  => $pasv->[1],
+      LocalAddr => ${*$ftp}{net_ftp_localaddr},
+      $family_key => ${*$ftp}{net_ftp_domain},
+      Timeout   => $ftp->timeout,
+      can_ssl() ? (
+        SSL_startHandshake => 0,
+        %{${*$ftp}{net_ftp_tlsargs}},
+      ):(),
+    ) or return;
+  } elsif (my $listen =  delete ${*$ftp}{net_ftp_listen}) {
+    $conn = $listen->accept($pkg) or return;
+    $conn->timeout($ftp->timeout);
+    close($listen);
+  } else {
+    croak("no listener in active mode");
+  }
+
+  if (( ${*$ftp}{net_ftp_tlsprot} || '') eq 'P') {
+    if ($conn->connect_SSL) {
+      # SSL handshake ok
+    } else {
+      carp("failed to ssl upgrade dataconn: $IO::Socket::SSL::SSL_ERROR");
+      return;
+    }
+  }
+
+  ${*$ftp}{net_ftp_dataconn} = $conn;
+  ${*$conn} = "";
+  ${*$conn}{net_ftp_cmd} = $ftp;
+  ${*$conn}{net_ftp_blksize} = ${*$ftp}{net_ftp_blksize};
+  return $conn;
+}
+
+
+sub _list_cmd {
+  my $ftp = shift;
+  my $cmd = uc shift;
+
+  delete ${*$ftp}{'net_ftp_port'};
+  delete ${*$ftp}{'net_ftp_pasv'};
+
+  my $data = $ftp->_data_cmd($cmd, @_);
+
+  return
+    unless (defined $data);
+
+  require Net::FTP::A;
+  bless $data, "Net::FTP::A";    # Force ASCII mode
+
+  my $databuf = '';
+  my $buf     = '';
+  my $blksize = ${*$ftp}{'net_ftp_blksize'};
+
+  while ($data->read($databuf, $blksize)) {
+    $buf .= $databuf;
+  }
+
+  my $list = [split(/\n/, $buf)];
+
+  $data->close();
+
+  if (EBCDIC) {
+    for (@$list) { $_ = $ftp->toebcdic($_) }
+  }
+
+  wantarray
+    ? @{$list}
+    : $list;
+}
+
+
+sub _data_cmd {
+  my $ftp   = shift;
+  my $cmd   = uc shift;
+  my $ok    = 1;
+  my $where = delete ${*$ftp}{'net_ftp_rest'} || 0;
+  my $arg;
+
+  for my $arg (@_) {
+    croak("Bad argument '$arg'\n")
+      if $arg =~ /[\r\n]/s;
+  }
+
+  if ( ${*$ftp}{'net_ftp_passive'}
+    && !defined ${*$ftp}{'net_ftp_pasv'}
+    && !defined ${*$ftp}{'net_ftp_port'})
+  {
+    return unless defined $ftp->pasv;
+
+    if ($where and !$ftp->_REST($where)) {
+      my ($status, $message) = ($ftp->status, $ftp->message);
+      $ftp->abort;
+      $ftp->set_status($status, $message);
+      return;
+    }
+
+    # first send command, then open data connection
+    # otherwise the peer might not do a full accept (with SSL
+    # handshake if PROT P)
+    $ftp->command($cmd, @_);
+    my $data = $ftp->_dataconn();
+    if (CMD_INFO == $ftp->response()) {
+      $data->reading
+        if $data && $cmd =~ /RETR|LIST|NLST|MLSD/;
+      return $data;
+    }
+    $data->_close if $data;
+
+    return;
+  }
+
+  $ok = $ftp->port
+    unless (defined ${*$ftp}{'net_ftp_port'}
+    || defined ${*$ftp}{'net_ftp_pasv'});
+
+  $ok = $ftp->_REST($where)
+    if $ok && $where;
+
+  return
+    unless $ok;
+
+  if ($cmd =~ /(STOR|APPE|STOU)/ and exists ${*$ftp}{net_ftp_allo} and
+      $ftp->supported("ALLO"))
+  {
+    $ftp->_ALLO(delete ${*$ftp}{net_ftp_allo})
+      or return;
+  }
+
+  $ftp->command($cmd, @_);
+
+  return 1
+    if (defined ${*$ftp}{'net_ftp_pasv'});
+
+  $ok = CMD_INFO == $ftp->response();
+
+  return $ok
+    unless exists ${*$ftp}{'net_ftp_intern_port'};
+
+  if ($ok) {
+    my $data = $ftp->_dataconn();
+
+    $data->reading
+      if $data && $cmd =~ /RETR|LIST|NLST|MLSD/;
+
+    return $data;
+  }
+
+
+  close(delete ${*$ftp}{'net_ftp_listen'});
+
+  return;
+}
+
+##
+## Over-ride methods (Net::Cmd)
+##
+
+
+sub debug_text { $_[2] =~ /^(pass|resp|acct)/i ? "$1 ....\n" : $_[2]; }
+
+
+sub command {
+  my $ftp = shift;
+
+  delete ${*$ftp}{'net_ftp_port'};
+  $ftp->SUPER::command(@_);
+}
+
+
+sub response {
+  my $ftp  = shift;
+  my $code = $ftp->SUPER::response() || 5;    # assume 500 if undef
+
+  delete ${*$ftp}{'net_ftp_pasv'}
+    if ($code != CMD_MORE && $code != CMD_INFO);
+
+  $code;
+}
+
+
+sub parse_response {
+  return ($1, $2 eq "-")
+    if $_[1] =~ s/^(\d\d\d)([- ]?)//o;
+
+  my $ftp = shift;
+
+  # Darn MS FTP server is a load of CRAP !!!!
+  # Expect to see undef here.
+  return ()
+    unless 0 + (${*$ftp}{'net_cmd_code'} || 0);
+
+  (${*$ftp}{'net_cmd_code'}, 1);
+}
+
+##
+## Allow 2 servers to talk directly
+##
+
+
+sub pasv_xfer_unique {
+  my ($sftp, $sfile, $dftp, $dfile) = @_;
+  $sftp->pasv_xfer($sfile, $dftp, $dfile, 1);
+}
+
+
+sub pasv_xfer {
+  my ($sftp, $sfile, $dftp, $dfile, $unique) = @_;
+
+  ($dfile = $sfile) =~ s#.*/##
+    unless (defined $dfile);
+
+  my $port = $sftp->pasv
+    or return;
+
+  $dftp->port($port)
+    or return;
+
+  return
+    unless ($unique ? $dftp->stou($dfile) : $dftp->stor($dfile));
+
+  unless ($sftp->retr($sfile) && $sftp->response == CMD_INFO) {
+    $sftp->retr($sfile);
+    $dftp->abort;
+    $dftp->response();
+    return;
+  }
+
+  $dftp->pasv_wait($sftp);
+}
+
+
+sub pasv_wait {
+  @_ == 2 or croak 'usage: $ftp->pasv_wait($non_pasv_server)';
+
+  my ($ftp, $non_pasv_server) = @_;
+  my ($file, $rin, $rout);
+
+  vec($rin = '', fileno($ftp), 1) = 1;
+  select($rout = $rin, undef, undef, undef);
+
+  my $dres = $ftp->response();
+  my $sres = $non_pasv_server->response();
+
+  return
+    unless $dres == CMD_OK && $sres == CMD_OK;
+
+  return
+    unless $ftp->ok() && $non_pasv_server->ok();
+
+  return $1
+    if $ftp->message =~ /unique file name:\s*(\S*)\s*\)/;
+
+  return $1
+    if $non_pasv_server->message =~ /unique file name:\s*(\S*)\s*\)/;
+
+  return 1;
+}
+
+
+sub feature {
+  @_ == 2 or croak 'usage: $ftp->feature($name)';
+  my ($ftp, $name) = @_;
+
+  my $feature = ${*$ftp}{net_ftp_feature} ||= do {
+    my @feat;
+
+    # Example response
+    # 211-Features:
+    #  MDTM
+    #  REST STREAM
+    #  SIZE
+    # 211 End
+
+    @feat = map { /^\s+(.*\S)/ } $ftp->message
+      if $ftp->_FEAT;
+
+    \@feat;
+  };
+
+  return grep { /^\Q$name\E\b/i } @$feature;
+}
+
+
+sub cmd { shift->command(@_)->response() }
+
+########################################
+#
+# RFC959 + RFC2428 + RFC4217 commands
+#
+
+
+sub _ABOR { shift->command("ABOR")->response() == CMD_OK }
+sub _ALLO { shift->command("ALLO", @_)->response() == CMD_OK }
+sub _CDUP { shift->command("CDUP")->response() == CMD_OK }
+sub _NOOP { shift->command("NOOP")->response() == CMD_OK }
+sub _PASV { shift->command("PASV")->response() == CMD_OK }
+sub _QUIT { shift->command("QUIT")->response() == CMD_OK }
+sub _DELE { shift->command("DELE", @_)->response() == CMD_OK }
+sub _CWD  { shift->command("CWD", @_)->response() == CMD_OK }
+sub _PORT { shift->command("PORT", @_)->response() == CMD_OK }
+sub _RMD  { shift->command("RMD", @_)->response() == CMD_OK }
+sub _MKD  { shift->command("MKD", @_)->response() == CMD_OK }
+sub _PWD  { shift->command("PWD", @_)->response() == CMD_OK }
+sub _TYPE { shift->command("TYPE", @_)->response() == CMD_OK }
+sub _RNTO { shift->command("RNTO", @_)->response() == CMD_OK }
+sub _RESP { shift->command("RESP", @_)->response() == CMD_OK }
+sub _MDTM { shift->command("MDTM", @_)->response() == CMD_OK }
+sub _SIZE { shift->command("SIZE", @_)->response() == CMD_OK }
+sub _HELP { shift->command("HELP", @_)->response() == CMD_OK }
+sub _STAT { shift->command("STAT", @_)->response() == CMD_OK }
+sub _FEAT { shift->command("FEAT", @_)->response() == CMD_OK }
+sub _PBSZ { shift->command("PBSZ", @_)->response() == CMD_OK }
+sub _PROT { shift->command("PROT", @_)->response() == CMD_OK }
+sub _CCC  { shift->command("CCC", @_)->response() == CMD_OK }
+sub _EPRT { shift->command("EPRT", @_)->response() == CMD_OK }
+sub _EPSV { shift->command("EPSV", @_)->response() == CMD_OK }
+sub _APPE { shift->command("APPE", @_)->response() == CMD_INFO }
+sub _LIST { shift->command("LIST", @_)->response() == CMD_INFO }
+sub _NLST { shift->command("NLST", @_)->response() == CMD_INFO }
+sub _RETR { shift->command("RETR", @_)->response() == CMD_INFO }
+sub _STOR { shift->command("STOR", @_)->response() == CMD_INFO }
+sub _STOU { shift->command("STOU", @_)->response() == CMD_INFO }
+sub _RNFR { shift->command("RNFR", @_)->response() == CMD_MORE }
+sub _REST { shift->command("REST", @_)->response() == CMD_MORE }
+sub _PASS { shift->command("PASS", @_)->response() }
+sub _ACCT { shift->command("ACCT", @_)->response() }
+sub _AUTH { shift->command("AUTH", @_)->response() }
+
+
+sub _USER {
+  my $ftp = shift;
+  my $ok  = $ftp->command("USER", @_)->response();
+
+  # A certain brain dead firewall :-)
+  $ok = $ftp->command("user", @_)->response()
+    unless $ok == CMD_MORE or $ok == CMD_OK;
+
+  $ok;
+}
+
+
+sub _SMNT { shift->unsupported(@_) }
+sub _MODE { shift->unsupported(@_) }
+sub _SYST { shift->unsupported(@_) }
+sub _STRU { shift->unsupported(@_) }
+sub _REIN { shift->unsupported(@_) }
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::FTP - FTP Client class
+
+=head1 SYNOPSIS
+
+    use Net::FTP;
+
+    $ftp = Net::FTP->new("some.host.name", Debug => 0)
+      or die "Cannot connect to some.host.name: $@";
+
+    $ftp->login("anonymous",'-anonymous@')
+      or die "Cannot login ", $ftp->message;
+
+    $ftp->cwd("/pub")
+      or die "Cannot change working directory ", $ftp->message;
+
+    $ftp->get("that.file")
+      or die "get failed ", $ftp->message;
+
+    $ftp->quit;
+
+=head1 DESCRIPTION
+
+C<Net::FTP> is a class implementing a simple FTP client in Perl as
+described in RFC959.  It provides wrappers for the commonly used subset of the
+RFC959 commands.
+If L<IO::Socket::IP> or L<IO::Socket::INET6> is installed it also provides
+support for IPv6 as defined in RFC2428.
+And with L<IO::Socket::SSL> installed it provides support for implicit FTPS
+and explicit FTPS as defined in RFC4217.
+
+The Net::FTP class is a subclass of Net::Cmd and (depending on avaibility) of
+IO::Socket::IP, IO::Socket::INET6 or IO::Socket::INET.
+
+=head2 Overview
+
+FTP stands for File Transfer Protocol.  It is a way of transferring
+files between networked machines.  The protocol defines a client
+(whose commands are provided by this module) and a server (not
+implemented in this module).  Communication is always initiated by the
+client, and the server responds with a message and a status code (and
+sometimes with data).
+
+The FTP protocol allows files to be sent to or fetched from the
+server.  Each transfer involves a B<local file> (on the client) and a
+B<remote file> (on the server).  In this module, the same file name
+will be used for both local and remote if only one is specified.  This
+means that transferring remote file C</path/to/file> will try to put
+that file in C</path/to/file> locally, unless you specify a local file
+name.
+
+The protocol also defines several standard B<translations> which the
+file can undergo during transfer.  These are ASCII, EBCDIC, binary,
+and byte.  ASCII is the default type, and indicates that the sender of
+files will translate the ends of lines to a standard representation
+which the receiver will then translate back into their local
+representation.  EBCDIC indicates the file being transferred is in
+EBCDIC format.  Binary (also known as image) format sends the data as
+a contiguous bit stream.  Byte format transfers the data as bytes, the
+values of which remain the same regardless of differences in byte size
+between the two machines (in theory - in practice you should only use
+this if you really know what you're doing).  This class does not support
+the EBCDIC or byte formats, and will default to binary instead if they
+are attempted.
+
+=head2 Class Methods
+
+=over 4
+
+=item C<new([$host][, %options])>
+
+This is the constructor for a new Net::FTP object. C<$host> is the
+name of the remote host to which an FTP connection is required.
+
+C<$host> is optional. If C<$host> is not given then it may instead be
+passed as the C<Host> option described below. 
+
+C<%options> are passed in a hash like fashion, using key and value pairs.
+Possible options are:
+
+B<Host> - FTP host to connect to. It may be a single scalar, as defined for
+the C<PeerAddr> option in L<IO::Socket::INET>, or a reference to
+an array with hosts to try in turn. The L</host> method will return the value
+which was used to connect to the host.
+
+B<Firewall> - The name of a machine which acts as an FTP firewall. This can be
+overridden by an environment variable C<FTP_FIREWALL>. If specified, and the
+given host cannot be directly connected to, then the
+connection is made to the firewall machine and the string C<@hostname> is
+appended to the login identifier. This kind of setup is also referred to
+as an ftp proxy.
+
+B<FirewallType> - The type of firewall running on the machine indicated by
+B<Firewall>. This can be overridden by an environment variable
+C<FTP_FIREWALL_TYPE>. For a list of permissible types, see the description of
+ftp_firewall_type in L<Net::Config>.
+
+B<BlockSize> - This is the block size that Net::FTP will use when doing
+transfers. (defaults to 10240)
+
+B<Port> - The port number to connect to on the remote machine for the
+FTP connection
+
+B<SSL> - If the connection should be done from start with SSL, contrary to later
+upgrade with C<starttls>.
+
+B<SSL_*> - SSL arguments which will be applied when upgrading the control or
+data connection to SSL. You can use SSL arguments as documented in
+L<IO::Socket::SSL>, but it will usually use the right arguments already.
+
+B<Timeout> - Set a timeout value in seconds (defaults to 120)
+
+B<Debug> - debug level (see the debug method in L<Net::Cmd>)
+
+B<Passive> - If set to a non-zero value then all data transfers will
+be done using passive mode. If set to zero then data transfers will be
+done using active mode.  If the machine is connected to the Internet
+directly, both passive and active mode should work equally well.
+Behind most firewall and NAT configurations passive mode has a better
+chance of working.  However, in some rare firewall configurations,
+active mode actually works when passive mode doesn't.  Some really old
+FTP servers might not implement passive transfers.  If not specified,
+then the transfer mode is set by the environment variable
+C<FTP_PASSIVE> or if that one is not set by the settings done by the
+F<libnetcfg> utility.  If none of these apply then passive mode is
+used.
+
+B<Hash> - If given a reference to a file handle (e.g., C<\*STDERR>),
+print hash marks (#) on that filehandle every 1024 bytes.  This
+simply invokes the C<hash()> method for you, so that hash marks
+are displayed for all transfers.  You can, of course, call C<hash()>
+explicitly whenever you'd like.
+
+B<LocalAddr> - Local address to use for all socket connections. This
+argument will be passed to the super class, i.e. L<IO::Socket::INET>
+or L<IO::Socket::IP>.
+
+B<Domain> - Domain to use, i.e. AF_INET or AF_INET6. This
+argument will be passed to the IO::Socket super class.
+This can be used to enforce IPv4 even with L<IO::Socket::IP>
+which would default to IPv6.
+B<Family> is accepted as alternative name for B<Domain>.
+
+If the constructor fails undef will be returned and an error message will
+be in $@
+
+=back
+
+=head2 Object Methods
+
+Unless otherwise stated all methods return either a I<true> or I<false>
+value, with I<true> meaning that the operation was a success. When a method
+states that it returns a value, failure will be returned as I<undef> or an
+empty list.
+
+C<Net::FTP> inherits from C<Net::Cmd> so methods defined in C<Net::Cmd> may
+be used to send commands to the remote FTP server in addition to the methods
+documented here.
+
+=over 4
+
+=item C<login([$login[, $password[, $account]]])>
+
+Log into the remote FTP server with the given login information. If
+no arguments are given then the C<Net::FTP> uses the C<Net::Netrc>
+package to lookup the login information for the connected host.
+If no information is found then a login of I<anonymous> is used.
+If no password is given and the login is I<anonymous> then I<anonymous@>
+will be used for password.
+
+If the connection is via a firewall then the C<authorize> method will
+be called with no arguments.
+
+=item C<starttls()>
+
+Upgrade existing plain connection to SSL.
+The SSL arguments have to be given in C<new> already because they are needed for
+data connections too.
+
+=item C<stoptls()>
+
+Downgrade existing SSL connection back to plain.
+This is needed to work with some FTP helpers at firewalls, which need to see the
+PORT and PASV commands and responses to dynamically open the necessary ports.
+In this case C<starttls> is usually only done to protect the authorization.
+
+=item C<prot($level)>
+
+Set what type of data channel protection the client and server will be using.
+Only C<$level>s "C" (clear) and "P" (private) are supported.
+
+=item C<host()>
+
+Returns the value used by the constructor, and passed to the IO::Socket super
+class to connect to the host.
+
+=item C<account($acct)>
+
+Set a string identifying the user's account.
+
+=item C<authorize([$auth[, $resp]])>
+
+This is a protocol used by some firewall ftp proxies. It is used
+to authorise the user to send data out.  If both arguments are not specified
+then C<authorize> uses C<Net::Netrc> to do a lookup.
+
+=item C<site($args)>
+
+Send a SITE command to the remote server and wait for a response.
+
+Returns most significant digit of the response code.
+
+=item C<ascii()>
+
+Transfer file in ASCII. CRLF translation will be done if required
+
+=item C<binary()>
+
+Transfer file in binary mode. No transformation will be done.
+
+B<Hint>: If both server and client machines use the same line ending for
+text files, then it will be faster to transfer all files in binary mode.
+
+=item C<type([$type])>
+
+Set or get if files will be transferred in ASCII or binary mode.
+
+=item C<rename($oldname, $newname)>
+
+Rename a file on the remote FTP server from C<$oldname> to C<$newname>. This
+is done by sending the RNFR and RNTO commands.
+
+=item C<delete($filename)>
+
+Send a request to the server to delete C<$filename>.
+
+=item C<cwd([$dir])>
+
+Attempt to change directory to the directory given in C<$dir>.  If
+C<$dir> is C<"..">, the FTP C<CDUP> command is used to attempt to
+move up one directory. If no directory is given then an attempt is made
+to change the directory to the root directory.
+
+=item C<cdup()>
+
+Change directory to the parent of the current directory.
+
+=item C<passive([$passive])>
+
+Set or get if data connections will be initiated in passive mode.
+
+=item C<pwd()>
+
+Returns the full pathname of the current directory.
+
+=item C<restart($where)>
+
+Set the byte offset at which to begin the next data transfer. Net::FTP simply
+records this value and uses it when during the next data transfer. For this
+reason this method will not return an error, but setting it may cause
+a subsequent data transfer to fail.
+
+=item C<rmdir($dir[, $recurse])>
+
+Remove the directory with the name C<$dir>. If C<$recurse> is I<true> then
+C<rmdir> will attempt to delete everything inside the directory.
+
+=item C<mkdir($dir[, $recurse])>
+
+Create a new directory with the name C<$dir>. If C<$recurse> is I<true> then
+C<mkdir> will attempt to create all the directories in the given path.
+
+Returns the full pathname to the new directory.
+
+=item C<alloc($size[, $record_size])>
+
+The alloc command allows you to give the ftp server a hint about the size
+of the file about to be transferred using the ALLO ftp command. Some storage
+systems use this to make intelligent decisions about how to store the file.
+The C<$size> argument represents the size of the file in bytes. The
+C<$record_size> argument indicates a maximum record or page size for files
+sent with a record or page structure.
+
+The size of the file will be determined, and sent to the server
+automatically for normal files so that this method need only be called if
+you are transferring data from a socket, named pipe, or other stream not
+associated with a normal file.
+
+=item C<ls([$dir])>
+
+Get a directory listing of C<$dir>, or the current directory.
+
+In an array context, returns a list of lines returned from the server. In
+a scalar context, returns a reference to a list.
+
+=item C<dir([$dir])>
+
+Get a directory listing of C<$dir>, or the current directory in long format.
+
+In an array context, returns a list of lines returned from the server. In
+a scalar context, returns a reference to a list.
+
+=item C<get($remote_file[, $local_file[, $where]])>
+
+Get C<$remote_file> from the server and store locally. C<$local_file> may be
+a filename or a filehandle. If not specified, the file will be stored in
+the current directory with the same leafname as the remote file.
+
+If C<$where> is given then the first C<$where> bytes of the file will
+not be transferred, and the remaining bytes will be appended to
+the local file if it already exists.
+
+Returns C<$local_file>, or the generated local file name if C<$local_file>
+is not given. If an error was encountered undef is returned.
+
+=item C<put($local_file[, $remote_file])>
+
+Put a file on the remote server. C<$local_file> may be a name or a filehandle.
+If C<$local_file> is a filehandle then C<$remote_file> must be specified. If
+C<$remote_file> is not specified then the file will be stored in the current
+directory with the same leafname as C<$local_file>.
+
+Returns C<$remote_file>, or the generated remote filename if C<$remote_file>
+is not given.
+
+B<NOTE>: If for some reason the transfer does not complete and an error is
+returned then the contents that had been transferred will not be remove
+automatically.
+
+=item C<put_unique($local_file[, $remote_file])>
+
+Same as put but uses the C<STOU> command.
+
+Returns the name of the file on the server.
+
+=item C<append($local_file[, $remote_file])>
+
+Same as put but appends to the file on the remote server.
+
+Returns C<$remote_file>, or the generated remote filename if C<$remote_file>
+is not given.
+
+=item C<unique_name()>
+
+Returns the name of the last file stored on the server using the
+C<STOU> command.
+
+=item C<mdtm($file)>
+
+Returns the I<modification time> of the given file
+
+=item C<size($file)>
+
+Returns the size in bytes for the given file as stored on the remote server.
+
+B<NOTE>: The size reported is the size of the stored file on the remote server.
+If the file is subsequently transferred from the server in ASCII mode
+and the remote server and local machine have different ideas about
+"End Of Line" then the size of file on the local machine after transfer
+may be different.
+
+=item C<supported($cmd)>
+
+Returns TRUE if the remote server supports the given command.
+
+=item C<hash([$filehandle_glob_ref[, $bytes_per_hash_mark]])>
+
+Called without parameters, or with the first argument false, hash marks
+are suppressed.  If the first argument is true but not a reference to a 
+file handle glob, then \*STDERR is used.  The second argument is the number
+of bytes per hash mark printed, and defaults to 1024.  In all cases the
+return value is a reference to an array of two:  the filehandle glob reference
+and the bytes per hash mark.
+
+=item C<feature($name)>
+
+Determine if the server supports the specified feature. The return
+value is a list of lines the server responded with to describe the
+options that it supports for the given feature. If the feature is
+unsupported then the empty list is returned.
+
+  if ($ftp->feature( 'MDTM' )) {
+    # Do something
+  }
+
+  if (grep { /\bTLS\b/ } $ftp->feature('AUTH')) {
+    # Server supports TLS
+  }
+
+=back
+
+The following methods can return different results depending on
+how they are called. If the user explicitly calls either
+of the C<pasv> or C<port> methods then these methods will
+return a I<true> or I<false> value. If the user does not
+call either of these methods then the result will be a
+reference to a C<Net::FTP::dataconn> based object.
+
+=over 4
+
+=item C<nlst([$dir])>
+
+Send an C<NLST> command to the server, with an optional parameter.
+
+=item C<list([$dir])>
+
+Same as C<nlst> but using the C<LIST> command
+
+=item C<retr($file)>
+
+Begin the retrieval of a file called C<$file> from the remote server.
+
+=item C<stor($file)>
+
+Tell the server that you wish to store a file. C<$file> is the
+name of the new file that should be created.
+
+=item C<stou($file)>
+
+Same as C<stor> but using the C<STOU> command. The name of the unique
+file which was created on the server will be available via the C<unique_name>
+method after the data connection has been closed.
+
+=item C<appe($file)>
+
+Tell the server that we want to append some data to the end of a file
+called C<$file>. If this file does not exist then create it.
+
+=back
+
+If for some reason you want to have complete control over the data connection,
+this includes generating it and calling the C<response> method when required,
+then the user can use these methods to do so.
+
+However calling these methods only affects the use of the methods above that
+can return a data connection. They have no effect on methods C<get>, C<put>,
+C<put_unique> and those that do not require data connections.
+
+=over 4
+
+=item C<port([$port])>
+
+=item C<eprt([$port])>
+
+Send a C<PORT> (IPv4) or C<EPRT> (IPv6) command to the server. If C<$port> is
+specified then it is sent to the server. If not, then a listen socket is created
+and the correct information sent to the server.
+
+=item C<pasv()>
+
+=item C<epsv()>
+
+Tell the server to go into passive mode (C<pasv> for IPv4, C<epsv> for IPv6).
+Returns the text that represents the port on which the server is listening, this
+text is in a suitable form to send to another ftp server using the C<port> or
+C<eprt> method.
+
+=back
+
+The following methods can be used to transfer files between two remote
+servers, providing that these two servers can connect directly to each other.
+
+=over 4
+
+=item C<pasv_xfer($src_file, $dest_server[, $dest_file ])>
+
+This method will do a file transfer between two remote ftp servers. If
+C<$dest_file> is omitted then the leaf name of C<$src_file> will be used.
+
+=item C<pasv_xfer_unique($src_file, $dest_server[, $dest_file ])>
+
+Like C<pasv_xfer> but the file is stored on the remote server using
+the STOU command.
+
+=item C<pasv_wait($non_pasv_server)>
+
+This method can be used to wait for a transfer to complete between a passive
+server and a non-passive server. The method should be called on the passive
+server with the C<Net::FTP> object for the non-passive server passed as an
+argument.
+
+=item C<abort()>
+
+Abort the current data transfer.
+
+=item C<quit()>
+
+Send the QUIT command to the remote FTP server and close the socket connection.
+
+=back
+
+=head2 Methods for the Adventurous
+
+=over 4
+
+=item C<quot($cmd[, $args])>
+
+Send a command, that Net::FTP does not directly support, to the remote
+server and wait for a response.
+
+Returns most significant digit of the response code.
+
+B<WARNING> This call should only be used on commands that do not require
+data connections. Misuse of this method can hang the connection.
+
+=item C<can_inet6()>
+
+Returns whether we can use IPv6.
+
+=item C<can_ssl()>
+
+Returns whether we can use SSL.
+
+=back
+
+=head2 The dataconn Class
+
+Some of the methods defined in C<Net::FTP> return an object which will
+be derived from the C<Net::FTP::dataconn> class. See L<Net::FTP::dataconn> for
+more details.
+
+=head2 Unimplemented
+
+The following RFC959 commands have not been implemented:
+
+=over 4
+
+=item C<SMNT>
+
+Mount a different file system structure without changing login or
+accounting information.
+
+=item C<HELP>
+
+Ask the server for "helpful information" (that's what the RFC says) on
+the commands it accepts.
+
+=item C<MODE>
+
+Specifies transfer mode (stream, block or compressed) for file to be
+transferred.
+
+=item C<SYST>
+
+Request remote server system identification.
+
+=item C<STAT>
+
+Request remote server status.
+
+=item C<STRU>
+
+Specifies file structure for file to be transferred.
+
+=item C<REIN>
+
+Reinitialize the connection, flushing all I/O and account information.
+
+=back
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head2 Reporting Bugs
+
+When reporting bugs/problems please include as much information as possible.
+It may be difficult for me to reproduce the problem as almost every setup
+is different.
+
+A small script which yields the problem will probably be of help. It would
+also be useful if this script was run with the extra options C<< Debug => 1 >>
+passed to the constructor, and the output sent with the bug report. If you
+cannot include a small script then please include a Debug trace from a
+run of your program which does yield the problem.
+
+=head1 SEE ALSO
+
+L<Net::Netrc>,
+L<Net::Cmd>,
+L<IO::Socket::SSL>;
+
+L<ftp(1)>,
+L<ftpd(8)>;
+
+L<https://www.ietf.org/rfc/rfc959.txt>,
+L<https://www.ietf.org/rfc/rfc2428.txt>,
+L<https://www.ietf.org/rfc/rfc4217.txt>.
+
+=head1 ACKNOWLEDGEMENTS
+
+Henry Gabryjelski E<lt>L<henryg@WPI.EDU|mailto:henryg@WPI.EDU>E<gt> - for the
+suggestion of creating directories recursively.
+
+Nathan Torkington E<lt>L<gnat@frii.com|mailto:gnat@frii.com>E<gt> - for some
+input on the documentation.
+
+Roderick Schertler E<lt>L<roderick@gate.net|mailto:roderick@gate.net>E<gt> - for
+various inputs
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2017, 2020, 2022 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/NNTP.pm

@@ -0,0 +1,1321 @@
+# Net::NNTP.pm
+#
+# Copyright (C) 1995-1997 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::NNTP;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use IO::Socket;
+use Net::Cmd;
+use Net::Config;
+use Time::Local;
+
+our $VERSION = "3.15";
+
+# Code for detecting if we can use SSL
+my $ssl_class = eval {
+  require IO::Socket::SSL;
+  # first version with default CA on most platforms
+  no warnings 'numeric';
+  IO::Socket::SSL->VERSION(2.007);
+} && 'IO::Socket::SSL';
+
+my $nossl_warn = !$ssl_class &&
+  'To use SSL please install IO::Socket::SSL with version>=2.007';
+
+# Code for detecting if we can use IPv6
+my $family_key = 'Domain';
+my $inet6_class = eval {
+  require IO::Socket::IP;
+  no warnings 'numeric';
+  IO::Socket::IP->VERSION(0.25) || die;
+  $family_key = 'Family';
+} && 'IO::Socket::IP' || eval {
+  require IO::Socket::INET6;
+  no warnings 'numeric';
+  IO::Socket::INET6->VERSION(2.62);
+} && 'IO::Socket::INET6';
+
+
+sub can_ssl   { $ssl_class };
+sub can_inet6 { $inet6_class };
+
+our @ISA = ('Net::Cmd', $inet6_class || 'IO::Socket::INET');
+
+
+sub new {
+  my $self = shift;
+  my $type = ref($self) || $self;
+  my ($host, %arg);
+  if (@_ % 2) {
+    $host = shift;
+    %arg  = @_;
+  }
+  else {
+    %arg  = @_;
+    $host = delete $arg{Host};
+  }
+  my $obj;
+
+  $host ||= $ENV{NNTPSERVER} || $ENV{NEWSHOST};
+
+  my $hosts = defined $host ? [$host] : $NetConfig{nntp_hosts};
+
+  @{$hosts} = qw(news)
+    unless @{$hosts};
+
+  my %connect = ( Proto => 'tcp');
+
+  if ($arg{SSL}) {
+    # SSL from start
+    die $nossl_warn if ! $ssl_class;
+    $arg{Port} ||= 563;
+    $connect{$_} = $arg{$_} for(grep { m{^SSL_} } keys %arg);
+  }
+
+  foreach my $o (qw(LocalAddr LocalPort Timeout)) {
+    $connect{$o} = $arg{$o} if exists $arg{$o};
+  }
+  $connect{$family_key} = $arg{Domain} || $arg{Family};
+  $connect{Timeout} = 120 unless defined $connect{Timeout};
+  $connect{PeerPort} = $arg{Port} || 'nntp(119)';
+  foreach my $h (@{$hosts}) {
+    $connect{PeerAddr} = $h;
+    $obj = $type->SUPER::new(%connect) or next;
+    ${*$obj}{'net_nntp_host'} = $h;
+    ${*$obj}{'net_nntp_arg'} = \%arg;
+    if ($arg{SSL}) {
+      Net::NNTP::_SSL->start_SSL($obj,%arg) or next;
+    }
+  }
+
+  return
+    unless defined $obj;
+
+  $obj->autoflush(1);
+  $obj->debug(exists $arg{Debug} ? $arg{Debug} : undef);
+
+  unless ($obj->response() == CMD_OK) {
+    $obj->close;
+    return;
+  }
+
+  my $c = $obj->code;
+  my @m = $obj->message;
+
+  unless (exists $arg{Reader} && $arg{Reader} == 0) {
+
+    # if server is INN and we have transfer rights the we are currently
+    # talking to innd not nnrpd
+    if ($obj->reader) {
+
+      # If reader succeeds the we need to consider this code to determine postok
+      $c = $obj->code;
+    }
+    else {
+
+      # I want to ignore this failure, so restore the previous status.
+      $obj->set_status($c, \@m);
+    }
+  }
+
+  ${*$obj}{'net_nntp_post'} = $c == 200 ? 1 : 0;
+
+  $obj;
+}
+
+
+sub host {
+  my $me = shift;
+  ${*$me}{'net_nntp_host'};
+}
+
+
+sub debug_text {
+  my $nntp  = shift;
+  my $inout = shift;
+  my $text  = shift;
+
+  if ( (ref($nntp) and $nntp->code == 350 and $text =~ /^(\S+)/)
+    || ($text =~ /^(authinfo\s+pass)/io))
+  {
+    $text = "$1 ....\n";
+  }
+
+  $text;
+}
+
+
+sub postok {
+  @_ == 1 or croak 'usage: $nntp->postok()';
+  my $nntp = shift;
+  ${*$nntp}{'net_nntp_post'} || 0;
+}
+
+
+sub starttls {
+  my $self = shift;
+  $ssl_class or die $nossl_warn;
+  $self->_STARTTLS or return;
+  Net::NNTP::_SSL->start_SSL($self,
+    %{ ${*$self}{'net_nntp_arg'} }, # (ssl) args given in new
+    @_   # more (ssl) args
+  ) or return;
+  return 1;
+}
+
+
+sub article {
+  @_ >= 1 && @_ <= 3 or croak 'usage: $nntp->article([{$msgid|$msgnum}[, $fh]])';
+  my $nntp = shift;
+  my @fh;
+
+  @fh = (pop) if @_ == 2 || (@_ && (ref($_[0]) || ref(\$_[0]) eq 'GLOB'));
+
+  $nntp->_ARTICLE(@_)
+    ? $nntp->read_until_dot(@fh)
+    : undef;
+}
+
+
+sub articlefh {
+  @_ >= 1 && @_ <= 2 or croak 'usage: $nntp->articlefh([{$msgid|$msgnum}])';
+  my $nntp = shift;
+
+  return unless $nntp->_ARTICLE(@_);
+  return $nntp->tied_fh;
+}
+
+
+sub authinfo {
+  @_ == 3 or croak 'usage: $nntp->authinfo($user, $pass)';
+  my ($nntp, $user, $pass) = @_;
+
+  $nntp->_AUTHINFO("USER",      $user) == CMD_MORE
+    && $nntp->_AUTHINFO("PASS", $pass) == CMD_OK;
+}
+
+
+sub authinfo_simple {
+  @_ == 3 or croak 'usage: $nntp->authinfo_simple($user, $pass)';
+  my ($nntp, $user, $pass) = @_;
+
+  $nntp->_AUTHINFO('SIMPLE') == CMD_MORE
+    && $nntp->command($user, $pass)->response == CMD_OK;
+}
+
+
+sub body {
+  @_ >= 1 && @_ <= 3 or croak 'usage: $nntp->body([{$msgid|$msgnum}[, $fh]])';
+  my $nntp = shift;
+  my @fh;
+
+  @fh = (pop) if @_ == 2 || (@_ && ref($_[0]) || ref(\$_[0]) eq 'GLOB');
+
+  $nntp->_BODY(@_)
+    ? $nntp->read_until_dot(@fh)
+    : undef;
+}
+
+
+sub bodyfh {
+  @_ >= 1 && @_ <= 2 or croak 'usage: $nntp->bodyfh([{$msgid|$msgnum}])';
+  my $nntp = shift;
+  return unless $nntp->_BODY(@_);
+  return $nntp->tied_fh;
+}
+
+
+sub head {
+  @_ >= 1 && @_ <= 3 or croak 'usage: $nntp->head([{$msgid|$msgnum}[, $fh]])';
+  my $nntp = shift;
+  my @fh;
+
+  @fh = (pop) if @_ == 2 || (@_ && ref($_[0]) || ref(\$_[0]) eq 'GLOB');
+
+  $nntp->_HEAD(@_)
+    ? $nntp->read_until_dot(@fh)
+    : undef;
+}
+
+
+sub headfh {
+  @_ >= 1 && @_ <= 2 or croak 'usage: $nntp->headfh([{$msgid|$msgnum}])';
+  my $nntp = shift;
+  return unless $nntp->_HEAD(@_);
+  return $nntp->tied_fh;
+}
+
+
+sub nntpstat {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->nntpstat([{$msgid|$msgnum}])';
+  my $nntp = shift;
+
+  $nntp->_STAT(@_) && $nntp->message =~ /(<[^>]+>)/o
+    ? $1
+    : undef;
+}
+
+
+sub group {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->group([$group])';
+  my $nntp = shift;
+  my $grp  = ${*$nntp}{'net_nntp_group'};
+
+  return $grp
+    unless (@_ || wantarray);
+
+  my $newgrp = shift;
+
+  $newgrp = (defined($grp) and length($grp)) ? $grp : ""
+    unless defined($newgrp) and length($newgrp);
+
+  return 
+    unless $nntp->_GROUP($newgrp) and $nntp->message =~ /(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/;
+
+  my ($count, $first, $last, $group) = ($1, $2, $3, $4);
+
+  # group may be replied as '(current group)'
+  $group = ${*$nntp}{'net_nntp_group'}
+    if $group =~ /\(/;
+
+  ${*$nntp}{'net_nntp_group'} = $group;
+
+  wantarray
+    ? ($count, $first, $last, $group)
+    : $group;
+}
+
+
+sub help {
+  @_ == 1 or croak 'usage: $nntp->help()';
+  my $nntp = shift;
+
+  $nntp->_HELP
+    ? $nntp->read_until_dot
+    : undef;
+}
+
+
+sub ihave {
+  @_ >= 2 or croak 'usage: $nntp->ihave($msgid[, $message])';
+  my $nntp  = shift;
+  my $msgid = shift;
+
+  $nntp->_IHAVE($msgid) && $nntp->datasend(@_)
+    ? @_ == 0 || $nntp->dataend
+    : undef;
+}
+
+
+sub last {
+  @_ == 1 or croak 'usage: $nntp->last()';
+  my $nntp = shift;
+
+  $nntp->_LAST && $nntp->message =~ /(<[^>]+>)/o
+    ? $1
+    : undef;
+}
+
+
+sub list {
+  @_ == 1 or croak 'usage: $nntp->list()';
+  my $nntp = shift;
+
+  $nntp->_LIST
+    ? $nntp->_grouplist
+    : undef;
+}
+
+
+sub newgroups {
+  @_ >= 2 or croak 'usage: $nntp->newgroups($since[, $distributions])';
+  my $nntp = shift;
+  my $since = _timestr(shift);
+  my $distributions = shift || "";
+
+  $distributions = join(",", @{$distributions})
+    if ref($distributions);
+
+  $nntp->_NEWGROUPS($since, $distributions)
+    ? $nntp->_grouplist
+    : undef;
+}
+
+
+sub newnews {
+  @_ >= 2 && @_ <= 4
+    or croak 'usage: $nntp->newnews($since[, $groups[, $distributions]])';
+  my $nntp = shift;
+  my $since = _timestr(shift);
+  my $groups = @_ ? shift : $nntp->group;
+  my $distributions = shift || "";
+
+  $groups ||= "*";
+  $groups = join(",", @{$groups})
+    if ref($groups);
+
+  $distributions = join(",", @{$distributions})
+    if ref($distributions);
+
+  $nntp->_NEWNEWS($groups, $since, $distributions)
+    ? $nntp->_articlelist
+    : undef;
+}
+
+
+sub next {
+  @_ == 1 or croak 'usage: $nntp->next()';
+  my $nntp = shift;
+
+  $nntp->_NEXT && $nntp->message =~ /(<[^>]+>)/o
+    ? $1
+    : undef;
+}
+
+
+sub post {
+  @_ >= 1 or croak 'usage: $nntp->post([$message])';
+  my $nntp = shift;
+
+  $nntp->_POST() && $nntp->datasend(@_)
+    ? @_ == 0 || $nntp->dataend
+    : undef;
+}
+
+
+sub postfh {
+  my $nntp = shift;
+  return unless $nntp->_POST();
+  return $nntp->tied_fh;
+}
+
+
+sub quit {
+  @_ == 1 or croak 'usage: $nntp->quit()';
+  my $nntp = shift;
+
+  $nntp->_QUIT;
+  $nntp->close;
+}
+
+
+sub slave {
+  @_ == 1 or croak 'usage: $nntp->slave()';
+  my $nntp = shift;
+
+  $nntp->_SLAVE;
+}
+
+##
+## The following methods are not implemented by all servers
+##
+
+
+sub active {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->active([$pattern])';
+  my $nntp = shift;
+
+  $nntp->_LIST('ACTIVE', @_)
+    ? $nntp->_grouplist
+    : undef;
+}
+
+
+sub active_times {
+  @_ == 1 or croak 'usage: $nntp->active_times()';
+  my $nntp = shift;
+
+  $nntp->_LIST('ACTIVE.TIMES')
+    ? $nntp->_grouplist
+    : undef;
+}
+
+
+sub distributions {
+  @_ == 1 or croak 'usage: $nntp->distributions()';
+  my $nntp = shift;
+
+  $nntp->_LIST('DISTRIBUTIONS')
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub distribution_patterns {
+  @_ == 1 or croak 'usage: $nntp->distribution_patterns()';
+  my $nntp = shift;
+
+  my $arr;
+  local $_;
+
+  ## no critic (ControlStructures::ProhibitMutatingListFunctions)
+  $nntp->_LIST('DISTRIB.PATS')
+    && ($arr = $nntp->read_until_dot)
+    ? [grep { /^\d/ && (chomp, $_ = [split /:/]) } @$arr]
+    : undef;
+}
+
+
+sub newsgroups {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->newsgroups([$pattern])';
+  my $nntp = shift;
+
+  $nntp->_LIST('NEWSGROUPS', @_)
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub overview_fmt {
+  @_ == 1 or croak 'usage: $nntp->overview_fmt()';
+  my $nntp = shift;
+
+  $nntp->_LIST('OVERVIEW.FMT')
+    ? $nntp->_articlelist
+    : undef;
+}
+
+
+sub subscriptions {
+  @_ == 1 or croak 'usage: $nntp->subscriptions()';
+  my $nntp = shift;
+
+  $nntp->_LIST('SUBSCRIPTIONS')
+    ? $nntp->_articlelist
+    : undef;
+}
+
+
+sub listgroup {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->listgroup([$group])';
+  my $nntp = shift;
+
+  $nntp->_LISTGROUP(@_)
+    ? $nntp->_articlelist
+    : undef;
+}
+
+
+sub reader {
+  @_ == 1 or croak 'usage: $nntp->reader()';
+  my $nntp = shift;
+
+  $nntp->_MODE('READER');
+}
+
+
+sub xgtitle {
+  @_ == 1 || @_ == 2 or croak 'usage: $nntp->xgtitle([$pattern])';
+  my $nntp = shift;
+
+  $nntp->_XGTITLE(@_)
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub xhdr {
+  @_ >= 2 && @_ <= 4 or croak 'usage: $nntp->xhdr($header[, $message_spec])';
+  my $nntp = shift;
+  my $header = shift;
+  my $arg = _msg_arg(@_);
+
+  $nntp->_XHDR($header, $arg)
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub xover {
+  @_ == 2 || @_ == 3 or croak 'usage: $nntp->xover($message_spec)';
+  my $nntp = shift;
+  my $arg  = _msg_arg(@_);
+
+  $nntp->_XOVER($arg)
+    ? $nntp->_fieldlist
+    : undef;
+}
+
+
+sub xpat {
+  @_ == 4 || @_ == 5 or croak 'usage: $nntp->xpat($header, $pattern, $message_spec )';
+  my $nntp = shift;
+  my $header = shift;
+  my $pattern = shift;
+  my $arg = _msg_arg(@_);
+
+  $pattern = join(" ", @$pattern)
+    if ref($pattern);
+
+  $nntp->_XPAT($header, $arg, $pattern)
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub xpath {
+  @_ == 2 or croak 'usage: $nntp->xpath($message_id)';
+  my ($nntp, $message_id) = @_;
+
+  return
+    unless $nntp->_XPATH($message_id);
+
+  my $m;
+  ($m = $nntp->message) =~ s/^\d+\s+//o;
+  my @p = split /\s+/, $m;
+
+  wantarray ? @p : $p[0];
+}
+
+
+sub xrover {
+  @_ == 2 || @_ == 3 or croak 'usage: $nntp->xrover($message_spec)';
+  my $nntp = shift;
+  my $arg  = _msg_arg(@_);
+
+  $nntp->_XROVER($arg)
+    ? $nntp->_description
+    : undef;
+}
+
+
+sub date {
+  @_ == 1 or croak 'usage: $nntp->date()';
+  my $nntp = shift;
+
+  $nntp->_DATE
+    && $nntp->message =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/
+    ? timegm($6, $5, $4, $3, $2 - 1, $1)
+    : undef;
+}
+
+
+##
+## Private subroutines
+##
+
+
+sub _msg_arg {
+  my $spec = shift;
+  my $arg  = "";
+
+  if (@_) {
+    carp "Depriciated passing of two message numbers, " . "pass a reference"
+      if $^W;
+    $spec = [$spec, $_[0]];
+  }
+
+  if (defined $spec) {
+    if (ref($spec)) {
+      $arg = $spec->[0];
+      if (defined $spec->[1]) {
+        $arg .= "-"
+          if $spec->[1] != $spec->[0];
+        $arg .= $spec->[1]
+          if $spec->[1] > $spec->[0];
+      }
+    }
+    else {
+      $arg = $spec;
+    }
+  }
+
+  $arg;
+}
+
+
+sub _timestr {
+  my $time = shift;
+  my @g    = reverse((gmtime($time))[0 .. 5]);
+  $g[1] += 1;
+  $g[0] %= 100;
+  sprintf "%02d%02d%02d %02d%02d%02d GMT", @g;
+}
+
+
+sub _grouplist {
+  my $nntp = shift;
+  my $arr  = $nntp->read_until_dot
+    or return;
+
+  my $hash = {};
+
+  foreach my $ln (@$arr) {
+    my @a = split(/[\s\n]+/, $ln);
+    $hash->{$a[0]} = [@a[1, 2, 3]];
+  }
+
+  $hash;
+}
+
+
+sub _fieldlist {
+  my $nntp = shift;
+  my $arr  = $nntp->read_until_dot
+    or return;
+
+  my $hash = {};
+
+  foreach my $ln (@$arr) {
+    my @a = split(/[\t\n]/, $ln);
+    my $m = shift @a;
+    $hash->{$m} = [@a];
+  }
+
+  $hash;
+}
+
+
+sub _articlelist {
+  my $nntp = shift;
+  my $arr  = $nntp->read_until_dot;
+
+  chomp(@$arr)
+    if $arr;
+
+  $arr;
+}
+
+
+sub _description {
+  my $nntp = shift;
+  my $arr  = $nntp->read_until_dot
+    or return;
+
+  my $hash = {};
+
+  foreach my $ln (@$arr) {
+    chomp($ln);
+
+    $hash->{$1} = $ln
+      if $ln =~ s/^\s*(\S+)\s*//o;
+  }
+
+  $hash;
+
+}
+
+##
+## The commands
+##
+
+
+sub _ARTICLE  { shift->command('ARTICLE',  @_)->response == CMD_OK }
+sub _AUTHINFO { shift->command('AUTHINFO', @_)->response }
+sub _BODY     { shift->command('BODY',     @_)->response == CMD_OK }
+sub _DATE      { shift->command('DATE')->response == CMD_INFO }
+sub _GROUP     { shift->command('GROUP', @_)->response == CMD_OK }
+sub _HEAD      { shift->command('HEAD', @_)->response == CMD_OK }
+sub _HELP      { shift->command('HELP', @_)->response == CMD_INFO }
+sub _IHAVE     { shift->command('IHAVE', @_)->response == CMD_MORE }
+sub _LAST      { shift->command('LAST')->response == CMD_OK }
+sub _LIST      { shift->command('LIST', @_)->response == CMD_OK }
+sub _LISTGROUP { shift->command('LISTGROUP', @_)->response == CMD_OK }
+sub _NEWGROUPS { shift->command('NEWGROUPS', @_)->response == CMD_OK }
+sub _NEWNEWS   { shift->command('NEWNEWS', @_)->response == CMD_OK }
+sub _NEXT      { shift->command('NEXT')->response == CMD_OK }
+sub _POST      { shift->command('POST', @_)->response == CMD_MORE }
+sub _QUIT      { shift->command('QUIT', @_)->response == CMD_OK }
+sub _SLAVE     { shift->command('SLAVE', @_)->response == CMD_OK }
+sub _STARTTLS  { shift->command("STARTTLS")->response() == CMD_MORE }
+sub _STAT      { shift->command('STAT', @_)->response == CMD_OK }
+sub _MODE      { shift->command('MODE', @_)->response == CMD_OK }
+sub _XGTITLE   { shift->command('XGTITLE', @_)->response == CMD_OK }
+sub _XHDR      { shift->command('XHDR', @_)->response == CMD_OK }
+sub _XPAT      { shift->command('XPAT', @_)->response == CMD_OK }
+sub _XPATH     { shift->command('XPATH', @_)->response == CMD_OK }
+sub _XOVER     { shift->command('XOVER', @_)->response == CMD_OK }
+sub _XROVER    { shift->command('XROVER', @_)->response == CMD_OK }
+sub _XTHREAD   { shift->unsupported }
+sub _XSEARCH   { shift->unsupported }
+sub _XINDEX    { shift->unsupported }
+
+##
+## IO/perl methods
+##
+
+
+sub DESTROY {
+  my $nntp = shift;
+  defined(fileno($nntp)) && $nntp->quit;
+}
+
+{
+  package Net::NNTP::_SSL;
+  our @ISA = ( $ssl_class ? ($ssl_class):(), 'Net::NNTP' );
+  sub starttls { die "NNTP connection is already in SSL mode" }
+  sub start_SSL {
+    my ($class,$nntp,%arg) = @_;
+    delete @arg{ grep { !m{^SSL_} } keys %arg };
+    ( $arg{SSL_verifycn_name} ||= $nntp->host )
+        =~s{(?<!:):[\w()]+$}{}; # strip port
+    $arg{SSL_hostname} = $arg{SSL_verifycn_name}
+        if ! defined $arg{SSL_hostname} && $class->can_client_sni;
+    my $ok = $class->SUPER::start_SSL($nntp,
+      SSL_verifycn_scheme => 'nntp',
+      %arg
+    );
+    $@ = $ssl_class->errstr if !$ok;
+    return $ok;
+  }
+}
+
+
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::NNTP - NNTP Client class
+
+=head1 SYNOPSIS
+
+    use Net::NNTP;
+
+    $nntp = Net::NNTP->new("some.host.name");
+    $nntp->quit;
+
+    # start with SSL, e.g. nntps
+    $nntp = Net::NNTP->new("some.host.name", SSL => 1);
+
+    # start with plain and upgrade to SSL
+    $nntp = Net::NNTP->new("some.host.name");
+    $nntp->starttls;
+
+
+=head1 DESCRIPTION
+
+C<Net::NNTP> is a class implementing a simple NNTP client in Perl as described
+in RFC977 and RFC4642.
+With L<IO::Socket::SSL> installed it also provides support for implicit and
+explicit TLS encryption, i.e. NNTPS or NNTP+STARTTLS.
+
+The Net::NNTP class is a subclass of Net::Cmd and (depending on avaibility) of
+IO::Socket::IP, IO::Socket::INET6 or IO::Socket::INET.
+
+=head2 Class Methods
+
+=over 4
+
+=item C<new([$host][, %options])>
+
+This is the constructor for a new Net::NNTP object. C<$host> is the
+name of the remote host to which a NNTP connection is required. If not
+given then it may be passed as the C<Host> option described below. If no host is passed
+then two environment variables are checked, first C<NNTPSERVER> then
+C<NEWSHOST>, then C<Net::Config> is checked, and if a host is not found
+then C<news> is used.
+
+C<%options> are passed in a hash like fashion, using key and value pairs.
+Possible options are:
+
+B<Host> - NNTP host to connect to. It may be a single scalar, as defined for
+the C<PeerAddr> option in L<IO::Socket::INET>, or a reference to
+an array with hosts to try in turn. The L</host> method will return the value
+which was used to connect to the host.
+
+B<Port> - port to connect to.
+Default - 119 for plain NNTP and 563 for immediate SSL (nntps).
+
+B<SSL> - If the connection should be done from start with SSL, contrary to later
+upgrade with C<starttls>.
+You can use SSL arguments as documented in L<IO::Socket::SSL>, but it will
+usually use the right arguments already.
+
+B<Timeout> - Maximum time, in seconds, to wait for a response from the
+NNTP server, a value of zero will cause all IO operations to block.
+(default: 120)
+
+B<Debug> - Enable the printing of debugging information to STDERR
+
+B<Reader> - If the remote server is INN then initially the connection
+will be to innd, by default C<Net::NNTP> will issue a C<MODE READER> command
+so that the remote server becomes nnrpd. If the C<Reader> option is given
+with a value of zero, then this command will not be sent and the
+connection will be left talking to innd.
+
+B<LocalAddr> and B<LocalPort> - These parameters are passed directly
+to IO::Socket to allow binding the socket to a specific local address and port.
+
+B<Domain> - This parameter is passed directly to IO::Socket and makes it
+possible to enforce IPv4 connections even if L<IO::Socket::IP> is used as super
+class. Alternatively B<Family> can be used.
+
+=back
+
+=head2 Object Methods
+
+Unless otherwise stated all methods return either a I<true> or I<false>
+value, with I<true> meaning that the operation was a success. When a method
+states that it returns a value, failure will be returned as I<undef> or an
+empty list.
+
+C<Net::NNTP> inherits from C<Net::Cmd> so methods defined in C<Net::Cmd> may
+be used to send commands to the remote NNTP server in addition to the methods
+documented here.
+
+=over 4
+
+=item C<host()>
+
+Returns the value used by the constructor, and passed to IO::Socket::INET,
+to connect to the host.
+
+=item C<starttls()>
+
+Upgrade existing plain connection to SSL.
+Any arguments necessary for SSL must be given in C<new> already.
+
+=item C<article([{$msgid|$msgnum}[, $fh]])>
+
+Retrieve the header, a blank line, then the body (text) of the
+specified article. 
+
+If C<$fh> is specified then it is expected to be a valid filehandle
+and the result will be printed to it, on success a true value will be
+returned. If C<$fh> is not specified then the return value, on success,
+will be a reference to an array containing the article requested, each
+entry in the array will contain one line of the article.
+
+If no arguments are passed then the current article in the currently
+selected newsgroup is fetched.
+
+C<$msgnum> is a numeric id of an article in the current newsgroup, and
+will change the current article pointer.  C<$msgid> is the message id of
+an article as shown in that article's header.  It is anticipated that the
+client will obtain the C<$msgid> from a list provided by the C<newnews>
+command, from references contained within another article, or from the
+message-id provided in the response to some other commands.
+
+If there is an error then C<undef> will be returned.
+
+=item C<body([{$msgid|$msgnum}[, [$fh]])>
+
+Like C<article> but only fetches the body of the article.
+
+=item C<head([{$msgid|$msgnum}[, [$fh]])>
+
+Like C<article> but only fetches the headers for the article.
+
+=item C<articlefh([{$msgid|$msgnum}])>
+
+=item C<bodyfh([{$msgid|$msgnum}])>
+
+=item C<headfh([{$msgid|$msgnum}])>
+
+These are similar to article(), body() and head(), but rather than
+returning the requested data directly, they return a tied filehandle
+from which to read the article.
+
+=item C<nntpstat([{$msgid|$msgnum}])>
+
+The C<nntpstat> command is similar to the C<article> command except that no
+text is returned.  When selecting by message number within a group,
+the C<nntpstat> command serves to set the "current article pointer" without
+sending text.
+
+Using the C<nntpstat> command to
+select by message-id is valid but of questionable value, since a
+selection by message-id does B<not> alter the "current article pointer".
+
+Returns the message-id of the "current article".
+
+=item C<group([$group])>
+
+Set and/or get the current group. If C<$group> is not given then information
+is returned on the current group.
+
+In a scalar context it returns the group name.
+
+In an array context the return value is a list containing, the number
+of articles in the group, the number of the first article, the number
+of the last article and the group name.
+
+=item C<help()>
+
+Request help text (a short summary of commands that are understood by this
+implementation) from the server. Returns the text or undef upon failure.
+
+=item C<ihave($msgid[, $message])>
+
+The C<ihave> command informs the server that the client has an article
+whose id is C<$msgid>.  If the server desires a copy of that
+article and C<$message> has been given then it will be sent.
+
+Returns I<true> if the server desires the article and C<$message> was
+successfully sent, if specified.
+
+If C<$message> is not specified then the message must be sent using the
+C<datasend> and C<dataend> methods from L<Net::Cmd>
+
+C<$message> can be either an array of lines or a reference to an array
+and must be encoded by the caller to octets of whatever encoding is required,
+e.g. by using the Encode module's C<encode()> function.
+
+=item C<last()>
+
+Set the "current article pointer" to the previous article in the current
+newsgroup.
+
+Returns the message-id of the article.
+
+=item C<date()>
+
+Returns the date on the remote server. This date will be in a UNIX time
+format (seconds since 1970)
+
+=item C<postok()>
+
+C<postok> will return I<true> if the servers initial response indicated
+that it will allow posting.
+
+=item C<authinfo($user, $pass)>
+
+Authenticates to the server (using the original AUTHINFO USER / AUTHINFO PASS
+form, defined in RFC2980) using the supplied username and password.  Please
+note that the password is sent in clear text to the server.  This command
+should not be used with valuable passwords unless the connection to the server
+is somehow protected.
+
+=item C<authinfo_simple($user, $pass)>
+
+Authenticates to the server (using the proposed NNTP V2 AUTHINFO SIMPLE form,
+defined and deprecated in RFC2980) using the supplied username and password.
+As with L</authinfo> the password is sent in clear text.
+
+=item C<list()>
+
+Obtain information about all the active newsgroups. The results is a reference
+to a hash where the key is a group name and each value is a reference to an
+array. The elements in this array are:- the last article number in the group,
+the first article number in the group and any information flags about the group.
+
+=item C<newgroups($since[, $distributions])>
+
+C<$since> is a time value and C<$distributions> is either a distribution
+pattern or a reference to a list of distribution patterns.
+The result is the same as C<list>, but the
+groups return will be limited to those created after C<$since> and, if
+specified, in one of the distribution areas in C<$distributions>. 
+
+=item C<newnews($since[, $groups[, $distributions]])>
+
+C<$since> is a time value. C<$groups> is either a group pattern or a reference
+to a list of group patterns. C<$distributions> is either a distribution
+pattern or a reference to a list of distribution patterns.
+
+Returns a reference to a list which contains the message-ids of all news posted
+after C<$since>, that are in a groups which matched C<$groups> and a
+distribution which matches C<$distributions>.
+
+=item C<next()>
+
+Set the "current article pointer" to the next article in the current
+newsgroup.
+
+Returns the message-id of the article.
+
+=item C<post([$message])>
+
+Post a new article to the news server. If C<$message> is specified and posting
+is allowed then the message will be sent.
+
+If C<$message> is not specified then the message must be sent using the
+C<datasend> and C<dataend> methods from L<Net::Cmd>
+
+C<$message> can be either an array of lines or a reference to an array
+and must be encoded by the caller to octets of whatever encoding is required,
+e.g. by using the Encode module's C<encode()> function.
+
+The message, either sent via C<datasend> or as the C<$message>
+parameter, must be in the format as described by RFC822 and must
+contain From:, Newsgroups: and Subject: headers.
+
+=item C<postfh()>
+
+Post a new article to the news server using a tied filehandle.  If
+posting is allowed, this method will return a tied filehandle that you
+can print() the contents of the article to be posted.  You must
+explicitly close() the filehandle when you are finished posting the
+article, and the return value from the close() call will indicate
+whether the message was successfully posted.
+
+=item C<slave()>
+
+Tell the remote server that I am not a user client, but probably another
+news server.
+
+=item C<quit()>
+
+Quit the remote server and close the socket connection.
+
+=item C<can_inet6()>
+
+Returns whether we can use IPv6.
+
+=item C<can_ssl()>
+
+Returns whether we can use SSL.
+
+=back
+
+=head2 Extension Methods
+
+These methods use commands that are not part of the RFC977 documentation. Some
+servers may not support all of them.
+
+=over 4
+
+=item C<newsgroups([$pattern])>
+
+Returns a reference to a hash where the keys are all the group names which
+match C<$pattern>, or all of the groups if no pattern is specified, and
+each value contains the description text for the group.
+
+=item C<distributions()>
+
+Returns a reference to a hash where the keys are all the possible
+distribution names and the values are the distribution descriptions.
+
+=item C<distribution_patterns()>
+
+Returns a reference to an array where each element, itself an array
+reference, consists of the three fields of a line of the distrib.pats list
+maintained by some NNTP servers, namely: a weight, a wildmat and a value
+which the client may use to construct a Distribution header.
+
+=item C<subscriptions()>
+
+Returns a reference to a list which contains a list of groups which
+are recommended for a new user to subscribe to.
+
+=item C<overview_fmt()>
+
+Returns a reference to an array which contain the names of the fields returned
+by C<xover>.
+
+=item C<active_times()>
+
+Returns a reference to a hash where the keys are the group names and each
+value is a reference to an array containing the time the groups was created
+and an identifier, possibly an Email address, of the creator.
+
+=item C<active([$pattern])>
+
+Similar to C<list> but only active groups that match the pattern are returned.
+C<$pattern> can be a group pattern.
+
+=item C<xgtitle($pattern)>
+
+Returns a reference to a hash where the keys are all the group names which
+match C<$pattern> and each value is the description text for the group.
+
+=item C<xhdr($header, $message_spec)>
+
+Obtain the header field C<$header> for all the messages specified. 
+
+The return value will be a reference
+to a hash where the keys are the message numbers and each value contains
+the text of the requested header for that message.
+
+=item C<xover($message_spec)>
+
+The return value will be a reference
+to a hash where the keys are the message numbers and each value contains
+a reference to an array which contains the overview fields for that
+message.
+
+The names of the fields can be obtained by calling C<overview_fmt>.
+
+=item C<xpath($message_id)>
+
+Returns the path name to the file on the server which contains the specified
+message.
+
+=item C<xpat($header, $pattern, $message_spec)>
+
+The result is the same as C<xhdr> except the is will be restricted to
+headers where the text of the header matches C<$pattern>
+
+=item C<xrover($message_spec)>
+
+The XROVER command returns reference information for the article(s)
+specified.
+
+Returns a reference to a HASH where the keys are the message numbers and the
+values are the References: lines from the articles
+
+=item C<listgroup([$group])>
+
+Returns a reference to a list of all the active messages in C<$group>, or
+the current group if C<$group> is not specified.
+
+=item C<reader()>
+
+Tell the server that you are a reader and not another server.
+
+This is required by some servers. For example if you are connecting to
+an INN server and you have transfer permission your connection will
+be connected to the transfer daemon, not the NNTP daemon. Issuing
+this command will cause the transfer daemon to hand over control
+to the NNTP daemon.
+
+Some servers do not understand this command, but issuing it and ignoring
+the response is harmless.
+
+=back
+
+=head2 Unsupported
+
+The following NNTP command are unsupported by the package, and there are
+no plans to do so.
+
+    AUTHINFO GENERIC
+    XTHREAD
+    XSEARCH
+    XINDEX
+
+=head2 Definitions
+
+=over 4
+
+=item $message_spec
+
+C<$message_spec> is either a single message-id, a single message number, or
+a reference to a list of two message numbers.
+
+If C<$message_spec> is a reference to a list of two message numbers and the
+second number in a range is less than or equal to the first then the range
+represents all messages in the group after the first message number.
+
+B<NOTE> For compatibility reasons only with earlier versions of Net::NNTP
+a message spec can be passed as a list of two numbers, this is deprecated
+and a reference to the list should now be passed
+
+=item $pattern
+
+The C<NNTP> protocol uses the C<WILDMAT> format for patterns.
+The WILDMAT format was first developed by Rich Salz based on
+the format used in the UNIX "find" command to articulate
+file names. It was developed to provide a uniform mechanism
+for matching patterns in the same manner that the UNIX shell
+matches filenames.
+
+Patterns are implicitly anchored at the
+beginning and end of each string when testing for a match.
+
+There are five pattern matching operations other than a strict
+one-to-one match between the pattern and the source to be
+checked for a match.
+
+The first is an asterisk C<*> to match any sequence of zero or more
+characters.
+
+The second is a question mark C<?> to match any single character. The
+third specifies a specific set of characters.
+
+The set is specified as a list of characters, or as a range of characters
+where the beginning and end of the range are separated by a minus (or dash)
+character, or as any combination of lists and ranges. The dash can
+also be included in the set as a character it if is the beginning
+or end of the set. This set is enclosed in square brackets. The
+close square bracket C<]> may be used in a set if it is the first
+character in the set.
+
+The fourth operation is the same as the
+logical not of the third operation and is specified the same
+way as the third with the addition of a caret character C<^> at
+the beginning of the test string just inside the open square
+bracket.
+
+The final operation uses the backslash character to
+invalidate the special meaning of an open square bracket C<[>,
+the asterisk, backslash or the question mark. Two backslashes in
+sequence will result in the evaluation of the backslash as a
+character with no special meaning.
+
+=over 4
+
+=item Examples
+
+=item C<[^]-]>
+
+matches any single character other than a close square
+bracket or a minus sign/dash.
+
+=item C<*bdc>
+
+matches any string that ends with the string "bdc"
+including the string "bdc" (without quotes).
+
+=item C<[0-9a-zA-Z]>
+
+matches any single printable alphanumeric ASCII character.
+
+=item C<a??d>
+
+matches any four character string which begins
+with a and ends with d.
+
+=back
+
+=back
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 SEE ALSO
+
+L<Net::Cmd>,
+L<IO::Socket::SSL>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-1997 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/Netrc.pm

@@ -0,0 +1,366 @@
+# Net::Netrc.pm
+#
+# Copyright (C) 1995-1998 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2014, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::Netrc;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use FileHandle;
+
+our $VERSION = "3.15";
+
+our $TESTING;
+
+my %netrc = ();
+
+sub _readrc {
+  my($class, $host) = @_;
+  my ($home, $file);
+
+  if ($^O eq "MacOS") {
+    $home = $ENV{HOME} || `pwd`;
+    chomp($home);
+    $file = ($home =~ /:$/ ? $home . "netrc" : $home . ":netrc");
+  }
+  else {
+
+    # Some OS's don't have "getpwuid", so we default to $ENV{HOME}
+    $home = eval { (getpwuid($>))[7] } || $ENV{HOME};
+    $home ||= $ENV{HOMEDRIVE} . ($ENV{HOMEPATH} || '') if defined $ENV{HOMEDRIVE};
+    if (-e $home . "/.netrc") {
+      $file = $home . "/.netrc";
+    }
+    elsif (-e $home . "/_netrc") {
+      $file = $home . "/_netrc";
+    }
+    else {
+      return unless $TESTING;
+    }
+  }
+
+  my ($login, $pass, $acct) = (undef, undef, undef);
+  my $fh;
+  local $_;
+
+  $netrc{default} = undef;
+
+  # OS/2 and Win32 do not handle stat in a way compatible with this check :-(
+  unless ($^O eq 'os2'
+    || $^O eq 'MSWin32'
+    || $^O eq 'MacOS'
+    || $^O =~ /^cygwin/)
+  {
+    my @stat = stat($file);
+
+    if (@stat) {
+      if ($stat[2] & 077) { ## no critic (ValuesAndExpressions::ProhibitLeadingZeros)
+        carp "Bad permissions: $file";
+        return;
+      }
+      if ($stat[4] != $<) {
+        carp "Not owner: $file";
+        return;
+      }
+    }
+  }
+
+  if ($fh = FileHandle->new($file, "r")) {
+    my ($mach, $macdef, $tok, @tok) = (0, 0);
+
+    while (<$fh>) {
+      undef $macdef if /\A\n\Z/;
+
+      if ($macdef) {
+        push(@$macdef, $_);
+        next;
+      }
+
+      s/^\s*//;
+      chomp;
+
+      while (length && s/^("((?:[^"]+|\\.)*)"|((?:[^\\\s]+|\\.)*))\s*//) {
+        (my $tok = $+) =~ s/\\(.)/$1/g;
+        push(@tok, $tok);
+      }
+
+    TOKEN:
+      while (@tok) {
+        if ($tok[0] eq "default") {
+          shift(@tok);
+          $mach = bless {}, $class;
+          $netrc{default} = [$mach];
+
+          next TOKEN;
+        }
+
+        last TOKEN
+          unless @tok > 1;
+
+        $tok = shift(@tok);
+
+        if ($tok eq "machine") {
+          my $host = shift @tok;
+          $mach = bless {machine => $host}, $class;
+
+          $netrc{$host} = []
+            unless exists($netrc{$host});
+          push(@{$netrc{$host}}, $mach);
+        }
+        elsif ($tok =~ /^(login|password|account)$/) {
+          next TOKEN unless $mach;
+          my $value = shift @tok;
+
+          # Following line added by rmerrell to remove '/' escape char in .netrc
+          $value =~ s/\/\\/\\/g;
+          $mach->{$1} = $value;
+        }
+        elsif ($tok eq "macdef") {
+          next TOKEN unless $mach;
+          my $value = shift @tok;
+          $mach->{macdef} = {}
+            unless exists $mach->{macdef};
+          $macdef = $mach->{machdef}{$value} = [];
+        }
+      }
+    }
+    $fh->close();
+  }
+}
+
+
+sub lookup {
+  my ($class, $mach, $login) = @_;
+
+  $class->_readrc()
+    unless exists $netrc{default};
+
+  $mach ||= 'default';
+  undef $login
+    if $mach eq 'default';
+
+  if (exists $netrc{$mach}) {
+    if (defined $login) {
+      foreach my $m (@{$netrc{$mach}}) {
+        return $m
+          if (exists $m->{login} && $m->{login} eq $login);
+      }
+      return;
+    }
+    return $netrc{$mach}->[0];
+  }
+
+  return $netrc{default}->[0]
+    if defined $netrc{default};
+
+  return;
+}
+
+
+sub login {
+  my $me = shift;
+
+  exists $me->{login}
+    ? $me->{login}
+    : undef;
+}
+
+
+sub account {
+  my $me = shift;
+
+  exists $me->{account}
+    ? $me->{account}
+    : undef;
+}
+
+
+sub password {
+  my $me = shift;
+
+  exists $me->{password}
+    ? $me->{password}
+    : undef;
+}
+
+
+sub lpa {
+  my $me = shift;
+  ($me->login, $me->password, $me->account);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::Netrc - OO interface to users netrc file
+
+=head1 SYNOPSIS
+
+    use Net::Netrc;
+
+    $mach = Net::Netrc->lookup('some.machine');
+    $login = $mach->login;
+    ($login, $password, $account) = $mach->lpa;
+
+=head1 DESCRIPTION
+
+C<Net::Netrc> is a class implementing a simple interface to the .netrc file
+used as by the ftp program.
+
+C<Net::Netrc> also implements security checks just like the ftp program,
+these checks are, first that the .netrc file must be owned by the user and 
+second the ownership permissions should be such that only the owner has
+read and write access. If these conditions are not met then a warning is
+output and the .netrc file is not read.
+
+=head2 The F<.netrc> File
+
+The .netrc file contains login and initialization information used by the
+auto-login process.  It resides in the user's home directory.  The following
+tokens are recognized; they may be separated by spaces, tabs, or new-lines:
+
+=over 4
+
+=item machine name
+
+Identify a remote machine name. The auto-login process searches
+the .netrc file for a machine token that matches the remote machine
+specified.  Once a match is made, the subsequent .netrc tokens
+are processed, stopping when the end of file is reached or an-
+other machine or a default token is encountered.
+
+=item default
+
+This is the same as machine name except that default matches
+any name.  There can be only one default token, and it must be
+after all machine tokens.  This is normally used as:
+
+    default login anonymous password user@site
+
+thereby giving the user automatic anonymous login to machines
+not specified in .netrc.
+
+=item login name
+
+Identify a user on the remote machine.  If this token is present,
+the auto-login process will initiate a login using the
+specified name.
+
+=item password string
+
+Supply a password.  If this token is present, the auto-login
+process will supply the specified string if the remote server
+requires a password as part of the login process.
+
+=item account string
+
+Supply an additional account password.  If this token is present,
+the auto-login process will supply the specified string
+if the remote server requires an additional account password.
+
+=item macdef name
+
+Define a macro. C<Net::Netrc> only parses this field to be compatible
+with I<ftp>.
+
+=back
+
+=head2 Class Methods
+
+The constructor for a C<Net::Netrc> object is not called new as it does not
+really create a new object. But instead is called C<lookup> as this is
+essentially what it does.
+
+=over 4
+
+=item C<lookup($machine[, $login])>
+
+Lookup and return a reference to the entry for C<$machine>. If C<$login> is given
+then the entry returned will have the given login. If C<$login> is not given then
+the first entry in the .netrc file for C<$machine> will be returned.
+
+If a matching entry cannot be found, and a default entry exists, then a
+reference to the default entry is returned.
+
+If there is no matching entry found and there is no default defined, or
+no .netrc file is found, then C<undef> is returned.
+
+=back
+
+=head2 Object Methods
+
+=over 4
+
+=item C<login()>
+
+Return the login id for the netrc entry
+
+=item C<password()>
+
+Return the password for the netrc entry
+
+=item C<account()>
+
+Return the account information for the netrc entry
+
+=item C<lpa()>
+
+Return a list of login, password and account information for the netrc entry
+
+=back
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 SEE ALSO
+
+L<Net::Cmd>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-1998 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2014, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/POP3.pm

@@ -0,0 +1,882 @@
+# Net::POP3.pm
+#
+# Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::POP3;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use IO::Socket;
+use Net::Cmd;
+use Net::Config;
+
+our $VERSION = "3.15";
+
+# Code for detecting if we can use SSL
+my $ssl_class = eval {
+  require IO::Socket::SSL;
+  # first version with default CA on most platforms
+  no warnings 'numeric';
+  IO::Socket::SSL->VERSION(2.007);
+} && 'IO::Socket::SSL';
+
+my $nossl_warn = !$ssl_class &&
+  'To use SSL please install IO::Socket::SSL with version>=2.007';
+
+# Code for detecting if we can use IPv6
+my $family_key = 'Domain';
+my $inet6_class = eval {
+  require IO::Socket::IP;
+  no warnings 'numeric';
+  IO::Socket::IP->VERSION(0.25) || die;
+  $family_key = 'Family';
+} && 'IO::Socket::IP' || eval {
+  require IO::Socket::INET6;
+  no warnings 'numeric';
+  IO::Socket::INET6->VERSION(2.62);
+} && 'IO::Socket::INET6';
+
+
+sub can_ssl   { $ssl_class };
+sub can_inet6 { $inet6_class };
+
+our @ISA = ('Net::Cmd', $inet6_class || 'IO::Socket::INET');
+
+sub new {
+  my $self = shift;
+  my $type = ref($self) || $self;
+  my ($host, %arg);
+  if (@_ % 2) {
+    $host = shift;
+    %arg  = @_;
+  }
+  else {
+    %arg  = @_;
+    $host = delete $arg{Host};
+  }
+  my $hosts = defined $host ? [$host] : $NetConfig{pop3_hosts};
+  my $obj;
+
+  if ($arg{SSL}) {
+    # SSL from start
+    die $nossl_warn if !$ssl_class;
+    $arg{Port} ||= 995;
+  }
+
+  $arg{Timeout} = 120 if ! defined $arg{Timeout};
+
+  foreach my $h (@{$hosts}) {
+    $obj = $type->SUPER::new(
+      PeerAddr => ($host = $h),
+      PeerPort => $arg{Port} || 'pop3(110)',
+      Proto => 'tcp',
+      $family_key => $arg{Domain} || $arg{Family},
+      LocalAddr => $arg{LocalAddr},
+      LocalPort => exists($arg{ResvPort}) ? $arg{ResvPort} : $arg{LocalPort},
+      Timeout => $arg{Timeout},
+      )
+      and last;
+  }
+
+  return
+    unless defined $obj;
+
+  ${*$obj}{'net_pop3_arg'} = \%arg;
+  ${*$obj}{'net_pop3_host'} = $host;
+  if ($arg{SSL}) {
+    Net::POP3::_SSL->start_SSL($obj,%arg) or return;
+  }
+
+  $obj->autoflush(1);
+  $obj->debug(exists $arg{Debug} ? $arg{Debug} : undef);
+
+  unless ($obj->response() == CMD_OK) {
+    $obj->close();
+    return;
+  }
+
+  ${*$obj}{'net_pop3_banner'} = $obj->message;
+
+  $obj;
+}
+
+
+sub host {
+  my $me = shift;
+  ${*$me}{'net_pop3_host'};
+}
+
+##
+## We don't want people sending me their passwords when they report problems
+## now do we :-)
+##
+
+
+sub debug_text { $_[2] =~ /^(pass|rpop)/i ? "$1 ....\n" : $_[2]; }
+
+
+sub login {
+  @_ >= 1 && @_ <= 3 or croak 'usage: $pop3->login([$user[, $pass]])';
+  my ($me, $user, $pass) = @_;
+
+  if (@_ <= 2) {
+    ($user, $pass) = $me->_lookup_credentials($user);
+  }
+
+  $me->user($user)
+    and $me->pass($pass);
+}
+
+sub starttls {
+  my $self = shift;
+  $ssl_class or die $nossl_warn;
+  $self->_STLS or return;
+  Net::POP3::_SSL->start_SSL($self,
+    %{ ${*$self}{'net_pop3_arg'} }, # (ssl) args given in new
+    @_   # more (ssl) args
+  ) or return;
+  return 1;
+}
+
+sub apop {
+  @_ >= 1 && @_ <= 3 or croak 'usage: $pop3->apop([$user[, $pass]])';
+  my ($me, $user, $pass) = @_;
+  my $banner;
+  my $md;
+
+  if (eval { local $SIG{__DIE__}; require Digest::MD5 }) {
+    $md = Digest::MD5->new();
+  }
+  elsif (eval { local $SIG{__DIE__}; require MD5 }) {
+    $md = MD5->new();
+  }
+  else {
+    carp "You need to install Digest::MD5 or MD5 to use the APOP command";
+    return;
+  }
+
+  return
+    unless ($banner = (${*$me}{'net_pop3_banner'} =~ /(<.*>)/)[0]);
+
+  if (@_ <= 2) {
+    ($user, $pass) = $me->_lookup_credentials($user);
+  }
+
+  $md->add($banner, $pass);
+
+  return
+    unless ($me->_APOP($user, $md->hexdigest));
+
+  $me->_get_mailbox_count();
+}
+
+
+sub user {
+  @_ == 2 or croak 'usage: $pop3->user($user)';
+  $_[0]->_USER($_[1]) ? 1 : undef;
+}
+
+
+sub pass {
+  @_ == 2 or croak 'usage: $pop3->pass($pass)';
+
+  my ($me, $pass) = @_;
+
+  return
+    unless ($me->_PASS($pass));
+
+  $me->_get_mailbox_count();
+}
+
+
+sub reset {
+  @_ == 1 or croak 'usage: $obj->reset()';
+
+  my $me = shift;
+
+  return 0
+    unless ($me->_RSET);
+
+  if (defined ${*$me}{'net_pop3_mail'}) {
+    local $_;
+    foreach (@{${*$me}{'net_pop3_mail'}}) {
+      delete $_->{'net_pop3_deleted'};
+    }
+  }
+}
+
+
+sub last {
+  @_ == 1 or croak 'usage: $obj->last()';
+
+  return
+    unless $_[0]->_LAST && $_[0]->message =~ /(\d+)/;
+
+  return $1;
+}
+
+
+sub top {
+  @_ == 2 || @_ == 3 or croak 'usage: $pop3->top($msgnum[, $numlines])';
+  my $me = shift;
+
+  return
+    unless $me->_TOP($_[0], $_[1] || 0);
+
+  $me->read_until_dot;
+}
+
+
+sub popstat {
+  @_ == 1 or croak 'usage: $pop3->popstat()';
+  my $me = shift;
+
+  return ()
+    unless $me->_STAT && $me->message =~ /(\d+)\D+(\d+)/;
+
+  ($1 || 0, $2 || 0);
+}
+
+
+sub list {
+  @_ == 1 || @_ == 2 or croak 'usage: $pop3->list([$msgnum])';
+  my $me = shift;
+
+  return
+    unless $me->_LIST(@_);
+
+  if (@_) {
+    $me->message =~ /\d+\D+(\d+)/;
+    return $1 || undef;
+  }
+
+  my $info = $me->read_until_dot
+    or return;
+
+  my %hash = map { (/(\d+)\D+(\d+)/) } @$info;
+
+  return \%hash;
+}
+
+
+sub get {
+  @_ == 2 or @_ == 3 or croak 'usage: $pop3->get($msgnum[, $fh])';
+  my $me = shift;
+
+  return
+    unless $me->_RETR(shift);
+
+  $me->read_until_dot(@_);
+}
+
+
+sub getfh {
+  @_ == 2 or croak 'usage: $pop3->getfh($msgnum)';
+  my $me = shift;
+
+  return unless $me->_RETR(shift);
+  return $me->tied_fh;
+}
+
+
+sub delete {
+  @_ == 2 or croak 'usage: $pop3->delete($msgnum)';
+  my $me = shift;
+  return 0 unless $me->_DELE(@_);
+  ${*$me}{'net_pop3_deleted'} = 1;
+}
+
+
+sub uidl {
+  @_ == 1 || @_ == 2 or croak 'usage: $pop3->uidl([$msgnum])';
+  my $me = shift;
+  my $uidl;
+
+  $me->_UIDL(@_)
+    or return;
+  if (@_) {
+    $uidl = ($me->message =~ /\d+\s+([\041-\176]+)/)[0];
+  }
+  else {
+    my $ref = $me->read_until_dot
+      or return;
+    $uidl = {};
+    foreach my $ln (@$ref) {
+      my ($msg, $uid) = $ln =~ /^\s*(\d+)\s+([\041-\176]+)/;
+      $uidl->{$msg} = $uid;
+    }
+  }
+  return $uidl;
+}
+
+
+sub ping {
+  @_ == 2 or croak 'usage: $pop3->ping($user)';
+  my $me = shift;
+
+  return () unless $me->_PING(@_) && $me->message =~ /(\d+)\D+(\d+)/;
+
+  ($1 || 0, $2 || 0);
+}
+
+
+sub _lookup_credentials {
+  my ($me, $user) = @_;
+
+  require Net::Netrc;
+
+       $user ||= eval { local $SIG{__DIE__}; (getpwuid($>))[0] }
+    || $ENV{NAME}
+    || $ENV{USER}
+    || $ENV{LOGNAME};
+
+  my $m = Net::Netrc->lookup(${*$me}{'net_pop3_host'}, $user);
+  $m ||= Net::Netrc->lookup(${*$me}{'net_pop3_host'});
+
+  my $pass = $m
+    ? $m->password || ""
+    : "";
+
+  ($user, $pass);
+}
+
+
+sub _get_mailbox_count {
+  my ($me) = @_;
+  my $ret = ${*$me}{'net_pop3_count'} =
+    ($me->message =~ /(\d+)\s+message/io) ? $1 : ($me->popstat)[0];
+
+  $ret ? $ret : "0E0";
+}
+
+
+sub _STAT { shift->command('STAT'       )->response() == CMD_OK }
+sub _LIST { shift->command('LIST',    @_)->response() == CMD_OK }
+sub _RETR { shift->command('RETR', $_[0])->response() == CMD_OK }
+sub _DELE { shift->command('DELE', $_[0])->response() == CMD_OK }
+sub _NOOP { shift->command('NOOP'       )->response() == CMD_OK }
+sub _RSET { shift->command('RSET'       )->response() == CMD_OK }
+sub _QUIT { shift->command('QUIT'       )->response() == CMD_OK }
+sub _TOP  { shift->command( 'TOP',    @_)->response() == CMD_OK }
+sub _UIDL { shift->command('UIDL',    @_)->response() == CMD_OK }
+sub _USER { shift->command('USER', $_[0])->response() == CMD_OK }
+sub _PASS { shift->command('PASS', $_[0])->response() == CMD_OK }
+sub _APOP { shift->command('APOP',    @_)->response() == CMD_OK }
+sub _PING { shift->command('PING', $_[0])->response() == CMD_OK }
+sub _RPOP { shift->command('RPOP', $_[0])->response() == CMD_OK }
+sub _LAST { shift->command('LAST'       )->response() == CMD_OK }
+sub _CAPA { shift->command('CAPA'       )->response() == CMD_OK }
+sub _STLS { shift->command("STLS",     )->response() == CMD_OK }
+
+
+sub quit {
+  my $me = shift;
+
+  $me->_QUIT;
+  $me->close;
+}
+
+
+sub DESTROY {
+  my $me = shift;
+
+  if (defined fileno($me) and ${*$me}{'net_pop3_deleted'}) {
+    $me->reset;
+    $me->quit;
+  }
+}
+
+##
+## POP3 has weird responses, so we emulate them to look the same :-)
+##
+
+
+sub response {
+  my $cmd  = shift;
+  my $str  = $cmd->getline() or return;
+  my $code = "500";
+
+  $cmd->debug_print(0, $str)
+    if ($cmd->debug);
+
+  if ($str =~ s/^\+OK\s*//io) {
+    $code = "200";
+  }
+  elsif ($str =~ s/^\+\s*//io) {
+    $code = "300";
+  }
+  else {
+    $str =~ s/^-ERR\s*//io;
+  }
+
+  ${*$cmd}{'net_cmd_resp'} = [$str];
+  ${*$cmd}{'net_cmd_code'} = $code;
+
+  substr($code, 0, 1);
+}
+
+
+sub capa {
+  my $this = shift;
+  my ($capa, %capabilities);
+
+  # Fake a capability here
+  $capabilities{APOP} = '' if ($this->banner() =~ /<.*>/);
+
+  if ($this->_CAPA()) {
+    $capabilities{CAPA} = 1;
+    $capa = $this->read_until_dot();
+    %capabilities = (%capabilities, map {/^\s*(\S+)\s*(.*)/} @$capa);
+  }
+  else {
+
+    # Check AUTH for SASL capabilities
+    if ($this->command('AUTH')->response() == CMD_OK) {
+      my $mechanism = $this->read_until_dot();
+      $capabilities{SASL} = join " ", map {m/([A-Z0-9_-]+)/} @{$mechanism};
+    }
+  }
+
+  return ${*$this}{'net_pop3e_capabilities'} = \%capabilities;
+}
+
+
+sub capabilities {
+  my $this = shift;
+
+  ${*$this}{'net_pop3e_capabilities'} || $this->capa;
+}
+
+
+sub auth {
+  my ($self, $username, $password) = @_;
+
+  eval {
+    require MIME::Base64;
+    require Authen::SASL;
+  } or $self->set_status(500, ["Need MIME::Base64 and Authen::SASL todo auth"]), return 0;
+
+  my $capa       = $self->capa;
+  my $mechanisms = $capa->{SASL} || 'CRAM-MD5';
+
+  my $sasl;
+
+  if (ref($username) and UNIVERSAL::isa($username, 'Authen::SASL')) {
+    $sasl = $username;
+    my $user_mech = $sasl->mechanism || '';
+    my @user_mech = split(/\s+/, $user_mech);
+    my %user_mech;
+    @user_mech{@user_mech} = ();
+
+    my @server_mech = split(/\s+/, $mechanisms);
+    my @mech = @user_mech
+      ? grep { exists $user_mech{$_} } @server_mech
+      : @server_mech;
+    unless (@mech) {
+      $self->set_status(
+        500,
+        [ 'Client SASL mechanisms (',
+          join(', ', @user_mech),
+          ') do not match the SASL mechnism the server announces (',
+          join(', ', @server_mech), ')',
+        ]
+      );
+      return 0;
+    }
+
+    $sasl->mechanism(join(" ", @mech));
+  }
+  else {
+    die "auth(username, password)" if not length $username;
+    $sasl = Authen::SASL->new(
+      mechanism => $mechanisms,
+      callback  => {
+        user     => $username,
+        pass     => $password,
+        authname => $username,
+      }
+    );
+  }
+
+  # We should probably allow the user to pass the host, but I don't
+  # currently know and SASL mechanisms that are used by smtp that need it
+  my ($hostname) = split /:/, ${*$self}{'net_pop3_host'};
+  my $client = eval { $sasl->client_new('pop', $hostname, 0) };
+
+  unless ($client) {
+    my $mech = $sasl->mechanism;
+    $self->set_status(
+      500,
+      [ " Authen::SASL failure: $@",
+        '(please check if your local Authen::SASL installation',
+        "supports mechanism '$mech'"
+      ]
+    );
+    return 0;
+  }
+
+  my ($token) = $client->client_start
+    or do {
+    my $mech = $client->mechanism;
+    $self->set_status(
+      500,
+      [ ' Authen::SASL failure:  $client->client_start ',
+        "mechanism '$mech' hostname #$hostname#",
+        $client->error
+      ]
+    );
+    return 0;
+    };
+
+  # We don't support sasl mechanisms that encrypt the socket traffic.
+  # todo that we would really need to change the ISA hierarchy
+  # so we don't inherit from IO::Socket, but instead hold it in an attribute
+
+  my @cmd = ("AUTH", $client->mechanism);
+  my $code;
+
+  push @cmd, MIME::Base64::encode_base64($token, '')
+    if defined $token and length $token;
+
+  while (($code = $self->command(@cmd)->response()) == CMD_MORE) {
+
+    my ($token) = $client->client_step(MIME::Base64::decode_base64(($self->message)[0])) or do {
+      $self->set_status(
+        500,
+        [ ' Authen::SASL failure:  $client->client_step ',
+          "mechanism '", $client->mechanism, " hostname #$hostname#, ",
+          $client->error
+        ]
+      );
+      return 0;
+    };
+
+    @cmd = (MIME::Base64::encode_base64(defined $token ? $token : '', ''));
+  }
+
+  $code == CMD_OK;
+}
+
+
+sub banner {
+  my $this = shift;
+
+  return ${*$this}{'net_pop3_banner'};
+}
+
+{
+  package Net::POP3::_SSL;
+  our @ISA = ( $ssl_class ? ($ssl_class):(), 'Net::POP3' );
+  sub starttls { die "POP3 connection is already in SSL mode" }
+  sub start_SSL {
+    my ($class,$pop3,%arg) = @_;
+    delete @arg{ grep { !m{^SSL_} } keys %arg };
+    ( $arg{SSL_verifycn_name} ||= $pop3->host )
+        =~s{(?<!:):[\w()]+$}{}; # strip port
+    $arg{SSL_hostname} = $arg{SSL_verifycn_name}
+        if ! defined $arg{SSL_hostname} && $class->can_client_sni;
+    $arg{SSL_verifycn_scheme} ||= 'pop3';
+    my $ok = $class->SUPER::start_SSL($pop3,%arg);
+    $@ = $ssl_class->errstr if !$ok;
+    return $ok;
+  }
+}
+
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::POP3 - Post Office Protocol 3 Client class (RFC1939)
+
+=head1 SYNOPSIS
+
+    use Net::POP3;
+
+    # Constructors
+    $pop = Net::POP3->new('pop3host');
+    $pop = Net::POP3->new('pop3host', Timeout => 60);
+    $pop = Net::POP3->new('pop3host', SSL => 1, Timeout => 60);
+
+    if ($pop->login($username, $password) > 0) {
+      my $msgnums = $pop->list; # hashref of msgnum => size
+      foreach my $msgnum (keys %$msgnums) {
+        my $msg = $pop->get($msgnum);
+        print @$msg;
+        $pop->delete($msgnum);
+      }
+    }
+
+    $pop->quit;
+
+=head1 DESCRIPTION
+
+This module implements a client interface to the POP3 protocol, enabling
+a perl5 application to talk to POP3 servers. This documentation assumes
+that you are familiar with the POP3 protocol described in RFC1939.
+With L<IO::Socket::SSL> installed it also provides support for implicit and
+explicit TLS encryption, i.e. POP3S or POP3+STARTTLS.
+
+A new Net::POP3 object must be created with the I<new> method. Once
+this has been done, all POP3 commands are accessed via method calls
+on the object.
+
+The Net::POP3 class is a subclass of Net::Cmd and (depending on avaibility) of
+IO::Socket::IP, IO::Socket::INET6 or IO::Socket::INET.
+
+=head2 Class Methods
+
+=over 4
+
+=item C<new([$host][, %options])>
+
+This is the constructor for a new Net::POP3 object. C<$host> is the
+name of the remote host to which an POP3 connection is required.
+
+C<$host> is optional. If C<$host> is not given then it may instead be
+passed as the C<Host> option described below. If neither is given then
+the C<POP3_Hosts> specified in C<Net::Config> will be used.
+
+C<%options> are passed in a hash like fashion, using key and value pairs.
+Possible options are:
+
+B<Host> - POP3 host to connect to. It may be a single scalar, as defined for
+the C<PeerAddr> option in L<IO::Socket::INET>, or a reference to
+an array with hosts to try in turn. The L</host> method will return the value
+which was used to connect to the host.
+
+B<Port> - port to connect to.
+Default - 110 for plain POP3 and 995 for POP3s (direct SSL).
+
+B<SSL> - If the connection should be done from start with SSL, contrary to later
+upgrade with C<starttls>.
+You can use SSL arguments as documented in L<IO::Socket::SSL>, but it will
+usually use the right arguments already.
+
+B<LocalAddr> and B<LocalPort> - These parameters are passed directly
+to IO::Socket to allow binding the socket to a specific local address and port.
+For compatibility with older versions B<ResvPort> can be used instead of
+B<LocalPort>.
+
+B<Domain> - This parameter is passed directly to IO::Socket and makes it
+possible to enforce IPv4 connections even if L<IO::Socket::IP> is used as super
+class. Alternatively B<Family> can be used.
+
+B<Timeout> - Maximum time, in seconds, to wait for a response from the
+POP3 server (default: 120)
+
+B<Debug> - Enable debugging information
+
+=back
+
+=head2 Object Methods
+
+Unless otherwise stated all methods return either a I<true> or I<false>
+value, with I<true> meaning that the operation was a success. When a method
+states that it returns a value, failure will be returned as I<undef> or an
+empty list.
+
+C<Net::POP3> inherits from C<Net::Cmd> so methods defined in C<Net::Cmd> may
+be used to send commands to the remote POP3 server in addition to the methods
+documented here.
+
+=over 4
+
+=item C<host()>
+
+Returns the value used by the constructor, and passed to IO::Socket::INET,
+to connect to the host.
+
+=item C<auth($username, $password)>
+
+Attempt SASL authentication.
+
+=item C<user($user)>
+
+Send the USER command.
+
+=item C<pass($pass)>
+
+Send the PASS command. Returns the number of messages in the mailbox.
+
+=item C<login([$user[, $pass]])>
+
+Send both the USER and PASS commands. If C<$pass> is not given the
+C<Net::POP3> uses C<Net::Netrc> to lookup the password using the host
+and username. If the username is not specified then the current user name
+will be used.
+
+Returns the number of messages in the mailbox. However if there are no
+messages on the server the string C<"0E0"> will be returned. This is
+will give a true value in a boolean context, but zero in a numeric context.
+
+If there was an error authenticating the user then I<undef> will be returned.
+
+=item C<starttls(%sslargs)>
+
+Upgrade existing plain connection to SSL.
+You can use SSL arguments as documented in L<IO::Socket::SSL>, but it will
+usually use the right arguments already.
+
+=item C<apop([$user[, $pass]])>
+
+Authenticate with the server identifying as C<$user> with password C<$pass>.
+Similar to L</login>, but the password is not sent in clear text.
+
+To use this method you must have the Digest::MD5 or the MD5 module installed,
+otherwise this method will return I<undef>.
+
+=item C<banner()>
+
+Return the sever's connection banner
+
+=item C<capa()>
+
+Return a reference to a hash of the capabilities of the server.  APOP
+is added as a pseudo capability.  Note that I've been unable to
+find a list of the standard capability values, and some appear to
+be multi-word and some are not.  We make an attempt at intelligently
+parsing them, but it may not be correct.
+
+=item C<capabilities()>
+
+Just like capa, but only uses a cache from the last time we asked
+the server, so as to avoid asking more than once.
+
+=item C<top($msgnum[, $numlines])>
+
+Get the header and the first C<$numlines> of the body for the message
+C<$msgnum>. Returns a reference to an array which contains the lines of text
+read from the server.
+
+=item C<list([$msgnum])>
+
+If called with an argument the C<list> returns the size of the message
+in octets.
+
+If called without arguments a reference to a hash is returned. The
+keys will be the C<$msgnum>'s of all undeleted messages and the values will
+be their size in octets.
+
+=item C<get($msgnum[, $fh])>
+
+Get the message C<$msgnum> from the remote mailbox. If C<$fh> is not given
+then get returns a reference to an array which contains the lines of
+text read from the server. If C<$fh> is given then the lines returned
+from the server are printed to the filehandle C<$fh>.
+
+=item C<getfh($msgnum)>
+
+As per get(), but returns a tied filehandle.  Reading from this
+filehandle returns the requested message.  The filehandle will return
+EOF at the end of the message and should not be reused.
+
+=item C<last()>
+
+Returns the highest C<$msgnum> of all the messages accessed.
+
+=item C<popstat()>
+
+Returns a list of two elements. These are the number of undeleted
+elements and the size of the mbox in octets.
+
+=item C<ping($user)>
+
+Returns a list of two elements. These are the number of new messages
+and the total number of messages for C<$user>.
+
+=item C<uidl([$msgnum])>
+
+Returns a unique identifier for C<$msgnum> if given. If C<$msgnum> is not
+given C<uidl> returns a reference to a hash where the keys are the
+message numbers and the values are the unique identifiers.
+
+=item C<delete($msgnum)>
+
+Mark message C<$msgnum> to be deleted from the remote mailbox. All messages
+that are marked to be deleted will be removed from the remote mailbox
+when the server connection closed.
+
+=item C<reset()>
+
+Reset the status of the remote POP3 server. This includes resetting the
+status of all messages to not be deleted.
+
+=item C<quit()>
+
+Quit and close the connection to the remote POP3 server. Any messages marked
+as deleted will be deleted from the remote mailbox.
+
+=item C<can_inet6()>
+
+Returns whether we can use IPv6.
+
+=item C<can_ssl()>
+
+Returns whether we can use SSL.
+
+=back
+
+=head2 Notes
+
+If a C<Net::POP3> object goes out of scope before C<quit> method is called
+then the C<reset> method will called before the connection is closed. This
+means that any messages marked to be deleted will not be.
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 SEE ALSO
+
+L<Net::Netrc>,
+L<Net::Cmd>,
+L<IO::Socket::SSL>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/Ping.pm

@@ -0,0 +1,2589 @@
+package Net::Ping;
+
+require 5.002;
+require Exporter;
+
+use strict;
+use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION
+            $def_timeout $def_proto $def_factor $def_family
+            $max_datasize $pingstring $hires $source_verify $syn_forking);
+use Fcntl qw( F_GETFL F_SETFL O_NONBLOCK );
+use Socket 2.007;
+use Socket qw( SOCK_DGRAM SOCK_STREAM SOCK_RAW AF_INET PF_INET IPPROTO_TCP
+	       SOL_SOCKET SO_ERROR SO_BROADCAST
+               IPPROTO_IP IP_TOS IP_TTL
+               inet_ntoa inet_aton getnameinfo sockaddr_in );
+use POSIX qw( ENOTCONN ECONNREFUSED ECONNRESET EINPROGRESS EWOULDBLOCK EAGAIN
+	      WNOHANG );
+use FileHandle;
+use Carp;
+use Time::HiRes;
+
+@ISA = qw(Exporter);
+@EXPORT = qw(pingecho);
+@EXPORT_OK = qw(wakeonlan);
+$VERSION = "2.76";
+
+# Globals
+
+$def_timeout = 5;           # Default timeout to wait for a reply
+$def_proto = "tcp";         # Default protocol to use for pinging
+$def_factor = 1.2;          # Default exponential backoff rate.
+$def_family = AF_INET;      # Default family.
+$max_datasize = 65535;      # Maximum data bytes. recommended: 1472 (Ethernet MTU: 1500)
+# The data we exchange with the server for the stream protocol
+$pingstring = "pingschwingping!\n";
+$source_verify = 1;         # Default is to verify source endpoint
+$syn_forking = 0;
+
+# Constants
+
+my $AF_INET6  = eval { Socket::AF_INET6() } || 30;
+my $AF_UNSPEC = eval { Socket::AF_UNSPEC() };
+my $AI_NUMERICHOST = eval { Socket::AI_NUMERICHOST() } || 4;
+my $NI_NUMERICHOST = eval { Socket::NI_NUMERICHOST() } || 2;
+my $IPPROTO_IPV6   = eval { Socket::IPPROTO_IPV6() }   || 41;
+my $NIx_NOSERV = eval { Socket::NIx_NOSERV() } || 2;
+#my $IPV6_HOPLIMIT  = eval { Socket::IPV6_HOPLIMIT() };  # ping6 -h 0-255
+my $qr_family = qr/^(?:(?:(:?ip)?v?(?:4|6))|${\AF_INET}|$AF_INET6)$/;
+my $qr_family4 = qr/^(?:(?:(:?ip)?v?4)|${\AF_INET})$/;
+my $Socket_VERSION = eval $Socket::VERSION;
+
+if ($^O =~ /Win32/i) {
+  # Hack to avoid this Win32 spewage:
+  # Your vendor has not defined POSIX macro ECONNREFUSED
+  my @pairs = (ECONNREFUSED => 10061, # "Unknown Error" Special Win32 Response?
+	       ENOTCONN     => 10057,
+	       ECONNRESET   => 10054,
+	       EINPROGRESS  => 10036,
+	       EWOULDBLOCK  => 10035,
+	  );
+  while (my $name = shift @pairs) {
+    my $value = shift @pairs;
+    # When defined, these all are non-zero
+    unless (eval $name) {
+      no strict 'refs';
+      *{$name} = defined prototype \&{$name} ? sub () {$value} : sub {$value};
+    }
+  }
+#  $syn_forking = 1;    # XXX possibly useful in < Win2K ?
+};
+
+# Description:  The pingecho() subroutine is provided for backward
+# compatibility with the original Net::Ping.  It accepts a host
+# name/IP and an optional timeout in seconds.  Create a tcp ping
+# object and try pinging the host.  The result of the ping is returned.
+
+sub pingecho
+{
+  my ($host,              # Name or IP number of host to ping
+      $timeout            # Optional timeout in seconds
+      ) = @_;
+  my ($p);                # A ping object
+
+  $p = Net::Ping->new("tcp", $timeout);
+  $p->ping($host);        # Going out of scope closes the connection
+}
+
+# Description:  The new() method creates a new ping object.  Optional
+# parameters may be specified for the protocol to use, the timeout in
+# seconds and the size in bytes of additional data which should be
+# included in the packet.
+#   After the optional parameters are checked, the data is constructed
+# and a socket is opened if appropriate.  The object is returned.
+
+sub new
+{
+  my ($this,
+      $proto,             # Optional protocol to use for pinging
+      $timeout,           # Optional timeout in seconds
+      $data_size,         # Optional additional bytes of data
+      $device,            # Optional device to use
+      $tos,               # Optional ToS to set
+      $ttl,               # Optional TTL to set
+      $family,            # Optional address family (AF_INET)
+      ) = @_;
+  my  $class = ref($this) || $this;
+  my  $self = {};
+  my ($cnt,               # Count through data bytes
+      $min_datasize       # Minimum data bytes required
+      );
+
+  bless($self, $class);
+  if (ref $proto eq 'HASH') { # support named args
+    for my $k (qw(proto timeout data_size device tos ttl family
+                  gateway host port bind retrans pingstring source_verify
+                  econnrefused dontfrag
+                  IPV6_USE_MIN_MTU IPV6_RECVPATHMTU IPV6_HOPLIMIT))
+    {
+      if (exists $proto->{$k}) {
+        $self->{$k} = $proto->{$k};
+        # some are still globals
+        if ($k eq 'pingstring') { $pingstring = $proto->{$k} }
+        if ($k eq 'source_verify') { $source_verify = $proto->{$k} }
+        # and some are local
+        $timeout = $proto->{$k}   if ($k eq 'timeout');
+        $data_size = $proto->{$k} if ($k eq 'data_size');
+        $device = $proto->{$k}    if ($k eq 'device');
+        $tos = $proto->{$k}       if ($k eq 'tos');
+        $ttl = $proto->{$k}       if ($k eq 'ttl');
+        $family = $proto->{$k}    if ($k eq 'family');
+        delete $proto->{$k};
+      }
+    }
+    if (%$proto) {
+      croak("Invalid named argument: ",join(" ",keys (%$proto)));
+    }
+    $proto = $self->{'proto'};
+  }
+
+  $proto = $def_proto unless $proto;          # Determine the protocol
+  croak('Protocol for ping must be "icmp", "icmpv6", "udp", "tcp", "syn", "stream" or "external"')
+    unless $proto =~ m/^(icmp|icmpv6|udp|tcp|syn|stream|external)$/;
+  $self->{proto} = $proto;
+
+  $timeout = $def_timeout unless defined $timeout;    # Determine the timeout
+  croak("Default timeout for ping must be greater than 0 seconds")
+    if $timeout <= 0;
+  $self->{timeout} = $timeout;
+
+  $self->{device} = $device;
+
+  $self->{tos} = $tos;
+
+  if ($self->{'host'}) {
+    my $host = $self->{'host'};
+    my $ip = $self->_resolv($host) or
+      carp("could not resolve host $host");
+    $self->{host} = $ip;
+    $self->{family} = $ip->{family};
+  }
+
+  if ($self->{bind}) {
+    my $addr = $self->{bind};
+    my $ip = $self->_resolv($addr)
+      or carp("could not resolve local addr $addr");
+    $self->{local_addr} = $ip;
+  } else {
+    $self->{local_addr} = undef;              # Don't bind by default
+  }
+
+  if ($self->{proto} eq 'icmp') {
+    croak('TTL must be from 0 to 255')
+      if ($ttl && ($ttl < 0 || $ttl > 255));
+    $self->{ttl} = $ttl;
+  }
+
+  if ($family) {
+    if ($family =~ $qr_family) {
+      if ($family =~ $qr_family4) {
+        $self->{family} = AF_INET;
+      } else {
+        $self->{family} = $AF_INET6;
+      }
+    } else {
+      croak('Family must be "ipv4" or "ipv6"')
+    }
+  } else {
+    if ($self->{proto} eq 'icmpv6') {
+      $self->{family} = $AF_INET6;
+    } else {
+      $self->{family} = $def_family;
+    }
+  }
+
+  $min_datasize = ($proto eq "udp") ? 1 : 0;  # Determine data size
+  $data_size = $min_datasize unless defined($data_size) && $proto ne "tcp";
+  # allow for fragmented packets if data_size>1472 (MTU 1500)
+  croak("Data for ping must be from $min_datasize to $max_datasize bytes")
+    if ($data_size < $min_datasize) || ($data_size > $max_datasize);
+  $data_size-- if $self->{proto} eq "udp";  # We provide the first byte
+  $self->{data_size} = $data_size;
+
+  $self->{data} = "";                       # Construct data bytes
+  for ($cnt = 0; $cnt < $self->{data_size}; $cnt++)
+  {
+    $self->{data} .= chr($cnt % 256);
+  }
+
+  # Default exponential backoff rate
+  $self->{retrans} = $def_factor unless exists $self->{retrans};
+  # Default Connection refused behavior
+  $self->{econnrefused} = undef unless exists $self->{econnrefused};
+
+  $self->{seq} = 0;                         # For counting packets
+  if ($self->{proto} eq "udp")              # Open a socket
+  {
+    $self->{proto_num} = eval { (getprotobyname('udp'))[2] } ||
+      croak("Can't udp protocol by name");
+    $self->{port_num} = $self->{port}
+      || (getservbyname('echo', 'udp'))[2]
+      || croak("Can't get udp echo port by name");
+    $self->{fh} = FileHandle->new();
+    socket($self->{fh}, PF_INET, SOCK_DGRAM,
+           $self->{proto_num}) ||
+             croak("udp socket error - $!");
+    $self->_setopts();
+  }
+  elsif ($self->{proto} eq "icmp")
+  {
+    croak("icmp ping requires root privilege") if !_isroot();
+    $self->{proto_num} = eval { (getprotobyname('icmp'))[2] } ||
+      croak("Can't get icmp protocol by name");
+    $self->{pid} = $$ & 0xffff;           # Save lower 16 bits of pid
+    $self->{fh} = FileHandle->new();
+    socket($self->{fh}, PF_INET, SOCK_RAW, $self->{proto_num}) ||
+      croak("icmp socket error - $!");
+    $self->_setopts();
+    if ($self->{'ttl'}) {
+      setsockopt($self->{fh}, IPPROTO_IP, IP_TTL, pack("I*", $self->{'ttl'}))
+        or croak "error configuring ttl to $self->{'ttl'} $!";
+    }
+  }
+  elsif ($self->{proto} eq "icmpv6")
+  {
+    #croak("icmpv6 ping requires root privilege") if !_isroot();
+    croak("Wrong family $self->{family} for icmpv6 protocol")
+      if $self->{family} and $self->{family} != $AF_INET6;
+    $self->{family} = $AF_INET6;
+    $self->{proto_num} = eval { (getprotobyname('ipv6-icmp'))[2] } ||
+      croak("Can't get ipv6-icmp protocol by name"); # 58
+    $self->{pid} = $$ & 0xffff;           # Save lower 16 bits of pid
+    $self->{fh} = FileHandle->new();
+    socket($self->{fh}, $AF_INET6, SOCK_RAW, $self->{proto_num}) ||
+      croak("icmp socket error - $!");
+    $self->_setopts();
+    if ($self->{'gateway'}) {
+      my $g = $self->{gateway};
+      my $ip = $self->_resolv($g)
+        or croak("nonexistent gateway $g");
+      $self->{family} eq $AF_INET6
+        or croak("gateway requires the AF_INET6 family");
+      $ip->{family} eq $AF_INET6
+        or croak("gateway address needs to be IPv6");
+      my $IPV6_NEXTHOP = eval { Socket::IPV6_NEXTHOP() } || 48; # IPV6_3542NEXTHOP, or 21
+      setsockopt($self->{fh}, $IPPROTO_IPV6, $IPV6_NEXTHOP, _pack_sockaddr_in($ip))
+        or croak "error configuring gateway to $g NEXTHOP $!";
+    }
+    if (exists $self->{IPV6_USE_MIN_MTU}) {
+      my $IPV6_USE_MIN_MTU = eval { Socket::IPV6_USE_MIN_MTU() } || 42;
+      setsockopt($self->{fh}, $IPPROTO_IPV6, $IPV6_USE_MIN_MTU,
+                 pack("I*", $self->{'IPV6_USE_MIN_MT'}))
+        or croak "error configuring IPV6_USE_MIN_MT} $!";
+    }
+    if (exists $self->{IPV6_RECVPATHMTU}) {
+      my $IPV6_RECVPATHMTU = eval { Socket::IPV6_RECVPATHMTU() } || 43;
+      setsockopt($self->{fh}, $IPPROTO_IPV6, $IPV6_RECVPATHMTU,
+                 pack("I*", $self->{'RECVPATHMTU'}))
+        or croak "error configuring IPV6_RECVPATHMTU $!";
+    }
+    if ($self->{'tos'}) {
+      my $proto = $self->{family} == AF_INET ? IPPROTO_IP : $IPPROTO_IPV6;
+      setsockopt($self->{fh}, $proto, IP_TOS, pack("I*", $self->{'tos'}))
+        or croak "error configuring tos to $self->{'tos'} $!";
+    }
+    if ($self->{'ttl'}) {
+      my $proto = $self->{family} == AF_INET ? IPPROTO_IP : $IPPROTO_IPV6;
+      setsockopt($self->{fh}, $proto, IP_TTL, pack("I*", $self->{'ttl'}))
+        or croak "error configuring ttl to $self->{'ttl'} $!";
+    }
+  }
+  elsif ($self->{proto} eq "tcp" || $self->{proto} eq "stream")
+  {
+    $self->{proto_num} = eval { (getprotobyname('tcp'))[2] } ||
+      croak("Can't get tcp protocol by name");
+    $self->{port_num} = $self->{port}
+      || (getservbyname('echo', 'tcp'))[2]
+      ||  croak("Can't get tcp echo port by name");
+    $self->{fh} = FileHandle->new();
+  }
+  elsif ($self->{proto} eq "syn")
+  {
+    $self->{proto_num} = eval { (getprotobyname('tcp'))[2] } ||
+      croak("Can't get tcp protocol by name");
+    $self->{port_num} = (getservbyname('echo', 'tcp'))[2] ||
+      croak("Can't get tcp echo port by name");
+    if ($syn_forking) {
+      $self->{fork_rd} = FileHandle->new();
+      $self->{fork_wr} = FileHandle->new();
+      pipe($self->{fork_rd}, $self->{fork_wr});
+      $self->{fh} = FileHandle->new();
+      $self->{good} = {};
+      $self->{bad} = {};
+    } else {
+      $self->{wbits} = "";
+      $self->{bad} = {};
+    }
+    $self->{syn} = {};
+    $self->{stop_time} = 0;
+  }
+
+  return($self);
+}
+
+# Description: Set the local IP address from which pings will be sent.
+# For ICMP, UDP and TCP pings, just saves the address to be used when 
+# the socket is opened.  Returns non-zero if successful; croaks on error.
+sub bind
+{
+  my ($self,
+      $local_addr         # Name or IP number of local interface
+      ) = @_;
+  my ($ip,                # Hash of addr (string), addr_in (packed), family
+      $h		  # resolved hash
+      );
+
+  croak("Usage: \$p->bind(\$local_addr)") unless @_ == 2;
+  croak("already bound") if defined($self->{local_addr}) &&
+    ($self->{proto} eq "udp" || $self->{proto} eq "icmp");
+
+  $ip = $self->_resolv($local_addr);
+  carp("nonexistent local address $local_addr") unless defined($ip);
+  $self->{local_addr} = $ip;
+
+  if (($self->{proto} ne "udp") && 
+      ($self->{proto} ne "icmp") && 
+      ($self->{proto} ne "tcp") && 
+      ($self->{proto} ne "syn"))
+  {
+    croak("Unknown protocol \"$self->{proto}\" in bind()");
+  }
+
+  return 1;
+}
+
+# Description: A select() wrapper that compensates for platform
+# peculiarities.
+sub mselect
+{
+    if ($_[3] > 0 and $^O eq 'MSWin32') {
+	# On windows, select() doesn't process the message loop,
+	# but sleep() will, allowing alarm() to interrupt the latter.
+	# So we chop up the timeout into smaller pieces and interleave
+	# select() and sleep() calls.
+	my $t = $_[3];
+	my $gran = 0.5;  # polling granularity in seconds
+	my @args = @_;
+	while (1) {
+	    $gran = $t if $gran > $t;
+	    my $nfound = select($_[0], $_[1], $_[2], $gran);
+	    undef $nfound if $nfound == -1;
+	    $t -= $gran;
+	    return $nfound if $nfound or !defined($nfound) or $t <= 0;
+
+	    sleep(0);
+	    ($_[0], $_[1], $_[2]) = @args;
+	}
+    }
+    else {
+	my $nfound = select($_[0], $_[1], $_[2], $_[3]);
+	undef $nfound if $nfound == -1;
+	return $nfound;
+    }
+}
+
+# Description: Allow UDP source endpoint comparison to be
+#              skipped for those remote interfaces that do
+#              not response from the same endpoint.
+
+sub source_verify
+{
+  my $self = shift;
+  $source_verify = 1 unless defined
+    ($source_verify = ((defined $self) && (ref $self)) ? shift() : $self);
+}
+
+# Description: Set whether or not the connect
+# behavior should enforce remote service
+# availability as well as reachability.
+
+sub service_check
+{
+  my $self = shift;
+  $self->{econnrefused} = 1 unless defined
+    ($self->{econnrefused} = shift());
+}
+
+sub tcp_service_check
+{
+  service_check(@_);
+}
+
+# Description: Set exponential backoff for retransmission.
+# Should be > 1 to retain exponential properties.
+# If set to 0, retransmissions are disabled.
+
+sub retrans
+{
+  my $self = shift;
+  $self->{retrans} = shift;
+}
+
+sub _IsAdminUser {
+  return unless $^O eq 'MSWin32' or $^O eq "cygwin";
+  return unless eval { require Win32 };
+  return unless defined &Win32::IsAdminUser;
+  return Win32::IsAdminUser();
+}
+
+sub _isroot {
+  if (($> and $^O ne 'VMS' and $^O ne 'cygwin')
+    or (($^O eq 'MSWin32' or $^O eq 'cygwin')
+        and !_IsAdminUser())
+    or ($^O eq 'VMS'
+        and (`write sys\$output f\$privilege("SYSPRV")` =~ m/FALSE/))) {
+      return 0;
+  }
+  else {
+    return 1;
+  }
+}
+
+# Description: Sets ipv6 reachability
+# REACHCONF was removed in RFC3542, ping6 -R supports it. requires root.
+
+sub IPV6_REACHCONF
+{
+  my $self = shift;
+  my $on = shift;
+  if ($on) {
+    my $reachconf = eval { Socket::IPV6_REACHCONF() };
+    if (!$reachconf) {
+      carp "IPV6_REACHCONF not supported on this platform";
+      return 0;
+    }
+    if (!_isroot()) {
+      carp "IPV6_REACHCONF requires root permissions";
+      return 0;
+    }
+    $self->{IPV6_REACHCONF} = 1;
+  }
+  else {
+    return $self->{IPV6_REACHCONF};
+  }
+}
+
+# Description: set it on or off.
+
+sub IPV6_USE_MIN_MTU
+{
+  my $self = shift;
+  my $on = shift;
+  if (defined $on) {
+    my $IPV6_USE_MIN_MTU = eval { Socket::IPV6_USE_MIN_MTU() } || 43;
+    #if (!$IPV6_USE_MIN_MTU) {
+    #  carp "IPV6_USE_MIN_MTU not supported on this platform";
+    #  return 0;
+    #}
+    $self->{IPV6_USE_MIN_MTU} = $on ? 1 : 0;
+    setsockopt($self->{fh}, $IPPROTO_IPV6, $IPV6_USE_MIN_MTU,
+               pack("I*", $self->{'IPV6_USE_MIN_MT'}))
+      or croak "error configuring IPV6_USE_MIN_MT} $!";
+  }
+  else {
+    return $self->{IPV6_USE_MIN_MTU};
+  }
+}
+
+# Description: notify an according MTU
+
+sub IPV6_RECVPATHMTU
+{
+  my $self = shift;
+  my $on = shift;
+  if ($on) {
+    my $IPV6_RECVPATHMTU = eval { Socket::IPV6_RECVPATHMTU() } || 43;
+    #if (!$RECVPATHMTU) {
+    #  carp "IPV6_RECVPATHMTU not supported on this platform";
+    #  return 0;
+    #}
+    $self->{IPV6_RECVPATHMTU} = 1;
+    setsockopt($self->{fh}, $IPPROTO_IPV6, $IPV6_RECVPATHMTU,
+               pack("I*", $self->{'IPV6_RECVPATHMTU'}))
+      or croak "error configuring IPV6_RECVPATHMTU} $!";
+  }
+  else {
+    return $self->{IPV6_RECVPATHMTU};
+  }
+}
+
+# Description: allows the module to use milliseconds as returned by
+# the Time::HiRes module
+
+$hires = 1;
+sub hires
+{
+  my $self = shift;
+  $hires = 1 unless defined
+    ($hires = ((defined $self) && (ref $self)) ? shift() : $self);
+}
+
+sub time
+{
+  return $hires ? Time::HiRes::time() : CORE::time();
+}
+
+# Description: Sets or clears the O_NONBLOCK flag on a file handle.
+sub socket_blocking_mode
+{
+  my ($self,
+      $fh,              # the file handle whose flags are to be modified
+      $block) = @_;     # if true then set the blocking
+                        # mode (clear O_NONBLOCK), otherwise
+                        # set the non-blocking mode (set O_NONBLOCK)
+
+  my $flags;
+  if ($^O eq 'MSWin32' || $^O eq 'VMS') {
+      # FIONBIO enables non-blocking sockets on windows and vms.
+      # FIONBIO is (0x80000000|(4<<16)|(ord('f')<<8)|126), as per winsock.h, ioctl.h
+      my $f = 0x8004667e;
+      my $v = pack("L", $block ? 0 : 1);
+      ioctl($fh, $f, $v) or croak("ioctl failed: $!");
+      return;
+  }
+  if ($flags = fcntl($fh, F_GETFL, 0)) {
+    $flags = $block ? ($flags & ~O_NONBLOCK) : ($flags | O_NONBLOCK);
+    if (!fcntl($fh, F_SETFL, $flags)) {
+      croak("fcntl F_SETFL: $!");
+    }
+  } else {
+    croak("fcntl F_GETFL: $!");
+  }
+}
+
+# Description: Ping a host name or IP number with an optional timeout.
+# First lookup the host, and return undef if it is not found.  Otherwise
+# perform the specific ping method based on the protocol.  Return the
+# result of the ping.
+
+sub ping
+{
+  my ($self,
+      $host,              # Name or IP number of host to ping
+      $timeout,           # Seconds after which ping times out
+      $family,            # Address family
+      ) = @_;
+  my ($ip,                # Hash of addr (string), addr_in (packed), family
+      $ret,               # The return value
+      $ping_time,         # When ping began
+      );
+
+  $host = $self->{host} if !defined $host and $self->{host};
+  croak("Usage: \$p->ping([ \$host [, \$timeout [, \$family]]])") if @_ > 4 or !$host;
+  $timeout = $self->{timeout} unless $timeout;
+  croak("Timeout must be greater than 0 seconds") if $timeout <= 0;
+
+  if ($family) {
+    if ($family =~ $qr_family) {
+      if ($family =~ $qr_family4) {
+        $self->{family_local} = AF_INET;
+      } else {
+        $self->{family_local} = $AF_INET6;
+      }
+    } else {
+      croak('Family must be "ipv4" or "ipv6"')
+    }
+  } else {
+    $self->{family_local} = $self->{family};
+  }
+  
+  $ip = $self->_resolv($host);
+  return () unless defined($ip);      # Does host exist?
+
+  # Dispatch to the appropriate routine.
+  $ping_time = &time();
+  if ($self->{proto} eq "external") {
+    $ret = $self->ping_external($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "udp") {
+    $ret = $self->ping_udp($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "icmp") {
+    $ret = $self->ping_icmp($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "icmpv6") {
+    $ret = $self->ping_icmpv6($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "tcp") {
+    $ret = $self->ping_tcp($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "stream") {
+    $ret = $self->ping_stream($ip, $timeout);
+  }
+  elsif ($self->{proto} eq "syn") {
+    $ret = $self->ping_syn($host, $ip, $ping_time, $ping_time+$timeout);
+  } else {
+    croak("Unknown protocol \"$self->{proto}\" in ping()");
+  }
+
+  return wantarray ? ($ret, &time() - $ping_time, $self->ntop($ip)) : $ret;
+}
+
+# Uses Net::Ping::External to do an external ping.
+sub ping_external {
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout,           # Seconds after which ping times out
+      $family
+     ) = @_;
+
+  $ip = $self->{host} if !defined $ip and $self->{host};
+  $timeout = $self->{timeout} if !defined $timeout and $self->{timeout};
+  my @addr = exists $ip->{addr_in}
+    ? ('ip' => $ip->{addr_in})
+    : ('host' => $ip->{host});
+
+  eval {
+    local @INC = @INC;
+    pop @INC if $INC[-1] eq '.';
+    require Net::Ping::External;
+  } or croak('Protocol "external" not supported on your system: Net::Ping::External not found');
+  return Net::Ping::External::ping(@addr, timeout => $timeout,
+                                   family => $family);
+}
+
+# h2ph "asm/socket.h"
+# require "asm/socket.ph";
+use constant SO_BINDTODEVICE  => 25;
+use constant ICMP_ECHOREPLY   => 0;   # ICMP packet types
+use constant ICMPv6_ECHOREPLY => 129; # ICMP packet types
+use constant ICMP_UNREACHABLE => 3;   # ICMP packet types
+use constant ICMPv6_UNREACHABLE => 1; # ICMP packet types
+use constant ICMPv6_NI_REPLY => 140;  # ICMP packet types
+use constant ICMP_ECHO        => 8;
+use constant ICMPv6_ECHO      => 128;
+use constant ICMP_TIME_EXCEEDED => 11; # ICMP packet types
+use constant ICMP_PARAMETER_PROBLEM => 12; # ICMP packet types
+use constant ICMP_TIMESTAMP   => 13;
+use constant ICMP_TIMESTAMP_REPLY => 14;
+use constant ICMP_STRUCT      => "C2 n3 A"; # Structure of a minimal ICMP packet
+use constant ICMP_TIMESTAMP_STRUCT => "C2 n3 N3"; # Structure of a minimal timestamp ICMP packet
+use constant SUBCODE          => 0; # No ICMP subcode for ECHO and ECHOREPLY
+use constant ICMP_FLAGS       => 0; # No special flags for send or recv
+use constant ICMP_PORT        => 0; # No port with ICMP
+use constant IP_MTU_DISCOVER  => 10; # linux only
+
+sub message_type
+{
+  my ($self,
+      $type
+      ) = @_;
+
+  croak "Setting message type only supported on 'icmp' protocol"
+    unless $self->{proto} eq 'icmp';
+
+  return $self->{message_type} || 'echo'
+    unless defined($type);
+
+  croak "Supported icmp message type are limited to 'echo' and 'timestamp': '$type' not supported"
+    unless $type =~ /^echo|timestamp$/i;
+
+  $self->{message_type} = lc($type);
+}
+
+sub ping_icmp
+{
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout            # Seconds after which ping times out
+      ) = @_;
+
+  my ($saddr,             # sockaddr_in with port and ip
+      $checksum,          # Checksum of ICMP packet
+      $msg,               # ICMP packet to send
+      $len_msg,           # Length of $msg
+      $rbits,             # Read bits, filehandles for reading
+      $nfound,            # Number of ready filehandles found
+      $finish_time,       # Time ping should be finished
+      $done,              # set to 1 when we are done
+      $ret,               # Return value
+      $recv_msg,          # Received message including IP header
+      $recv_msg_len,      # Length of recevied message, less any additional data
+      $from_saddr,        # sockaddr_in of sender
+      $from_port,         # Port packet was sent from
+      $from_ip,           # Packed IP of sender
+      $timestamp_msg,     # ICMP timestamp message type
+      $from_type,         # ICMP type
+      $from_subcode,      # ICMP subcode
+      $from_chk,          # ICMP packet checksum
+      $from_pid,          # ICMP packet id
+      $from_seq,          # ICMP packet sequence
+      $from_msg           # ICMP message
+      );
+
+  $ip = $self->{host} if !defined $ip and $self->{host};
+  $timeout = $self->{timeout} if !defined $timeout and $self->{timeout};
+  $timestamp_msg = $self->{message_type} && $self->{message_type} eq 'timestamp' ? 1 : 0;
+
+  socket($self->{fh}, $ip->{family}, SOCK_RAW, $self->{proto_num}) ||
+    croak("icmp socket error - $!");
+
+  if (defined $self->{local_addr} &&
+      !CORE::bind($self->{fh}, _pack_sockaddr_in(0, $self->{local_addr}))) {
+    croak("icmp bind error - $!");
+  }
+  $self->_setopts();
+
+  $self->{seq} = ($self->{seq} + 1) % 65536; # Increment sequence
+  $checksum = 0;                          # No checksum for starters
+  if ($ip->{family} == AF_INET) {
+    if ($timestamp_msg) {
+      $msg = pack(ICMP_TIMESTAMP_STRUCT, ICMP_TIMESTAMP, SUBCODE,
+                  $checksum, $self->{pid}, $self->{seq}, 0, 0, 0);
+    } else {
+      $msg = pack(ICMP_STRUCT . $self->{data_size}, ICMP_ECHO, SUBCODE,
+                  $checksum, $self->{pid}, $self->{seq}, $self->{data});
+    }
+  } else {
+                                          # how to get SRC
+    my $pseudo_header = pack('a16a16Nnn', $ip->{addr_in}, $ip->{addr_in}, 8+length($self->{data}), 0, 0x003a);
+    $msg = pack(ICMP_STRUCT . $self->{data_size}, ICMPv6_ECHO, SUBCODE,
+                $checksum, $self->{pid}, $self->{seq}, $self->{data});
+    $msg = $pseudo_header.$msg
+  }
+  $checksum = Net::Ping->checksum($msg);
+  if ($ip->{family} == AF_INET) {
+    if ($timestamp_msg) {
+      $msg = pack(ICMP_TIMESTAMP_STRUCT, ICMP_TIMESTAMP, SUBCODE,
+                  $checksum, $self->{pid}, $self->{seq}, 0, 0, 0);
+    } else {
+      $msg = pack(ICMP_STRUCT . $self->{data_size}, ICMP_ECHO, SUBCODE,
+                  $checksum, $self->{pid}, $self->{seq}, $self->{data});
+    }
+  } else {
+    $msg = pack(ICMP_STRUCT . $self->{data_size}, ICMPv6_ECHO, SUBCODE,
+                $checksum, $self->{pid}, $self->{seq}, $self->{data});
+  }
+  $len_msg = length($msg);
+  $saddr = _pack_sockaddr_in(ICMP_PORT, $ip);
+  $self->{from_ip} = undef;
+  $self->{from_type} = undef;
+  $self->{from_subcode} = undef;
+  send($self->{fh}, $msg, ICMP_FLAGS, $saddr); # Send the message
+
+  $rbits = "";
+  vec($rbits, $self->{fh}->fileno(), 1) = 1;
+  $ret = 0;
+  $done = 0;
+  $finish_time = &time() + $timeout;      # Must be done by this time
+  while (!$done && $timeout > 0)          # Keep trying if we have time
+  {
+    $nfound = mselect((my $rout=$rbits), undef, undef, $timeout); # Wait for packet
+    $timeout = $finish_time - &time();    # Get remaining time
+    if (!defined($nfound))                # Hmm, a strange error
+    {
+      $ret = undef;
+      $done = 1;
+    }
+    elsif ($nfound)                     # Got a packet from somewhere
+    {
+      $recv_msg = "";
+      $from_pid = -1;
+      $from_seq = -1;
+      $from_saddr = recv($self->{fh}, $recv_msg, 1500, ICMP_FLAGS);
+      $recv_msg_len = length($recv_msg) - length($self->{data});
+      ($from_port, $from_ip) = _unpack_sockaddr_in($from_saddr, $ip->{family});
+      # ICMP echo includes the header and ICMPv6 doesn't.
+      # IPv4 length($recv_msg) is 28 (20 header + 8 payload)
+      # while IPv6 length is only 8 (sans header).
+      my $off = ($ip->{family} == AF_INET) ? 20 : 0; # payload offset
+      ($from_type, $from_subcode) = unpack("C2", substr($recv_msg, $off, 2));
+      if ($from_type == ICMP_TIMESTAMP_REPLY) {
+        ($from_pid, $from_seq) = unpack("n3", substr($recv_msg, $off + 4, 4))
+          if length $recv_msg >= $off + 8;
+      } elsif ($from_type == ICMP_ECHOREPLY || $from_type == ICMPv6_ECHOREPLY) {
+        #warn "ICMP_ECHOREPLY: ", $ip->{family}, " ",$recv_msg, ":", length($recv_msg);
+        ($from_pid, $from_seq) = unpack("n2", substr($recv_msg, $off + 4, 4))
+          if $recv_msg_len == $off + 8;
+      } elsif ($from_type == ICMPv6_NI_REPLY) {
+        ($from_pid, $from_seq) = unpack("n2", substr($recv_msg, 4, 4))
+          if ($ip->{family} == $AF_INET6 && length $recv_msg == 8);
+      } else {
+        #warn "ICMP: ", $from_type, " ",$ip->{family}, " ",$recv_msg, ":", length($recv_msg);
+        ($from_pid, $from_seq) = unpack("n2", substr($recv_msg, $off + 32, 4))
+          if length $recv_msg >= $off + 36;
+      }
+      $self->{from_ip} = $from_ip;
+      $self->{from_type} = $from_type;
+      $self->{from_subcode} = $from_subcode;
+      next if ($from_pid != $self->{pid});
+      next if ($from_seq != $self->{seq});
+      if (! $source_verify || ($self->ntop($from_ip) eq $self->ntop($ip))) { # Does the packet check out?
+        if (!$timestamp_msg && (($from_type == ICMP_ECHOREPLY) || ($from_type == ICMPv6_ECHOREPLY))) {
+          $ret = 1;
+          $done = 1;
+        } elsif ($timestamp_msg && $from_type == ICMP_TIMESTAMP_REPLY) {
+          $ret = 1;
+          $done = 1;
+        } elsif (($from_type == ICMP_UNREACHABLE) || ($from_type == ICMPv6_UNREACHABLE)) {
+          $done = 1;
+        } elsif ($from_type == ICMP_TIME_EXCEEDED) {
+          $ret = 0;
+          $done = 1;
+        }
+      }
+    } else {     # Oops, timed out
+      $done = 1;
+    }
+  }
+  return $ret;
+}
+
+sub ping_icmpv6
+{
+  shift->ping_icmp(@_);
+}
+
+sub icmp_result {
+  my ($self) = @_;
+  my $addr = $self->{from_ip} || "";
+  $addr = "\0\0\0\0" unless 4 == length $addr;
+  return ($self->ntop($addr),($self->{from_type} || 0), ($self->{from_subcode} || 0));
+}
+
+# Description:  Do a checksum on the message.  Basically sum all of
+# the short words and fold the high order bits into the low order bits.
+
+sub checksum
+{
+  my ($class,
+      $msg            # The message to checksum
+      ) = @_;
+  my ($len_msg,       # Length of the message
+      $num_short,     # The number of short words in the message
+      $short,         # One short word
+      $chk            # The checksum
+      );
+
+  $len_msg = length($msg);
+  $num_short = int($len_msg / 2);
+  $chk = 0;
+  foreach $short (unpack("n$num_short", $msg))
+  {
+    $chk += $short;
+  }                                           # Add the odd byte in
+  $chk += (unpack("C", substr($msg, $len_msg - 1, 1)) << 8) if $len_msg % 2;
+  $chk = ($chk >> 16) + ($chk & 0xffff);      # Fold high into low
+  return(~(($chk >> 16) + $chk) & 0xffff);    # Again and complement
+}
+
+
+# Description:  Perform a tcp echo ping.  Since a tcp connection is
+# host specific, we have to open and close each connection here.  We
+# can't just leave a socket open.  Because of the robust nature of
+# tcp, it will take a while before it gives up trying to establish a
+# connection.  Therefore, we use select() on a non-blocking socket to
+# check against our timeout.  No data bytes are actually
+# sent since the successful establishment of a connection is proof
+# enough of the reachability of the remote host.  Also, tcp is
+# expensive and doesn't need our help to add to the overhead.
+
+sub ping_tcp
+{
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout            # Seconds after which ping times out
+      ) = @_;
+  my ($ret                # The return value
+      );
+
+  $ip = $self->{host} if !defined $ip and $self->{host};
+  $timeout = $self->{timeout} if !defined $timeout and $self->{timeout};
+
+  $! = 0;
+  $ret = $self -> tcp_connect( $ip, $timeout);
+  if (!$self->{econnrefused} &&
+      $! == ECONNREFUSED) {
+    $ret = 1;  # "Connection refused" means reachable
+  }
+  $self->{fh}->close();
+  return $ret;
+}
+
+sub tcp_connect
+{
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout            # Seconds after which connect times out
+      ) = @_;
+  my ($saddr);            # Packed IP and Port
+
+  $ip = $self->{host} if !defined $ip and $self->{host};
+  $timeout = $self->{timeout} if !defined $timeout and $self->{timeout};
+
+  $saddr = _pack_sockaddr_in($self->{port_num}, $ip);
+
+  my $ret = 0;            # Default to unreachable
+
+  my $do_socket = sub {
+    socket($self->{fh}, $ip->{family}, SOCK_STREAM, $self->{proto_num}) ||
+      croak("tcp socket error - $!");
+    if (defined $self->{local_addr} &&
+        !CORE::bind($self->{fh}, _pack_sockaddr_in(0, $self->{local_addr}))) {
+      croak("tcp bind error - $!");
+    }
+    $self->_setopts();
+  };
+  my $do_connect = sub {
+    $self->{ip} = $ip->{addr_in};
+    # ECONNREFUSED is 10061 on MSWin32. If we pass it as child error through $?,
+    # we'll get (10061 & 255) = 77, so we cannot check it in the parent process.
+    return ($ret = connect($self->{fh}, $saddr) || ($! == ECONNREFUSED && !$self->{econnrefused}));
+  };
+  my $do_connect_nb = sub {
+    # Set O_NONBLOCK property on filehandle
+    $self->socket_blocking_mode($self->{fh}, 0);
+
+    # start the connection attempt
+    if (!connect($self->{fh}, $saddr)) {
+      if ($! == ECONNREFUSED) {
+        $ret = 1 unless $self->{econnrefused};
+      } elsif ($! != EINPROGRESS && ($^O ne 'MSWin32' || $! != EWOULDBLOCK)) {
+        # EINPROGRESS is the expected error code after a connect()
+        # on a non-blocking socket.  But if the kernel immediately
+        # determined that this connect() will never work,
+        # Simply respond with "unreachable" status.
+        # (This can occur on some platforms with errno
+        # EHOSTUNREACH or ENETUNREACH.)
+        return 0;
+      } else {
+        # Got the expected EINPROGRESS.
+        # Just wait for connection completion...
+        my ($wbits, $wout, $wexc);
+        $wout = $wexc = $wbits = "";
+        vec($wbits, $self->{fh}->fileno, 1) = 1;
+
+        my $nfound = mselect(undef,
+			    ($wout = $wbits),
+			    ($^O eq 'MSWin32' ? ($wexc = $wbits) : undef),
+			    $timeout);
+        warn("select: $!") unless defined $nfound;
+
+        if ($nfound && vec($wout, $self->{fh}->fileno, 1)) {
+          # the socket is ready for writing so the connection
+          # attempt completed. test whether the connection
+          # attempt was successful or not
+
+          if (getpeername($self->{fh})) {
+            # Connection established to remote host
+            $ret = 1;
+          } else {
+            # TCP ACK will never come from this host
+            # because there was an error connecting.
+
+            # This should set $! to the correct error.
+            my $char;
+            sysread($self->{fh},$char,1);
+            $! = ECONNREFUSED if ($! == EAGAIN && $^O =~ /cygwin/i);
+
+            $ret = 1 if (!$self->{econnrefused}
+                         && $! == ECONNREFUSED);
+          }
+        } else {
+          # the connection attempt timed out (or there were connect
+	  # errors on Windows)
+	  if ($^O =~ 'MSWin32') {
+	      # If the connect will fail on a non-blocking socket,
+	      # winsock reports ECONNREFUSED as an exception, and we
+	      # need to fetch the socket-level error code via getsockopt()
+	      # instead of using the thread-level error code that is in $!.
+	      if ($nfound && vec($wexc, $self->{fh}->fileno, 1)) {
+		  $! = unpack("i", getsockopt($self->{fh}, SOL_SOCKET,
+			                      SO_ERROR));
+	      }
+	  }
+        }
+      }
+    } else {
+      # Connection established to remote host
+      $ret = 1;
+    }
+
+    # Unset O_NONBLOCK property on filehandle
+    $self->socket_blocking_mode($self->{fh}, 1);
+    $self->{ip} = $ip->{addr_in};
+    return $ret;
+  };
+
+  if ($syn_forking) {
+    # Buggy Winsock API doesn't allow nonblocking connect.
+    # Hence, if our OS is Windows, we need to create a separate
+    # process to do the blocking connect attempt.
+    # XXX Above comments are not true at least for Win2K, where
+    # nonblocking connect works.
+
+    $| = 1; # Clear buffer prior to fork to prevent duplicate flushing.
+    $self->{'tcp_chld'} = fork;
+    if (!$self->{'tcp_chld'}) {
+      if (!defined $self->{'tcp_chld'}) {
+        # Fork did not work
+        warn "Fork error: $!";
+        return 0;
+      }
+      &{ $do_socket }();
+
+      # Try a slow blocking connect() call
+      # and report the status to the parent.
+      if ( &{ $do_connect }() ) {
+        $self->{fh}->close();
+        # No error
+        exit 0;
+      } else {
+        # Pass the error status to the parent
+        # Make sure that $! <= 255
+        exit($! <= 255 ? $! : 255);
+      }
+    }
+
+    &{ $do_socket }();
+
+    my $patience = &time() + $timeout;
+
+    my ($child, $child_errno);
+    $? = 0; $child_errno = 0;
+    # Wait up to the timeout
+    # And clean off the zombie
+    do {
+      $child = waitpid($self->{'tcp_chld'}, &WNOHANG());
+      $child_errno = $? >> 8;
+      select(undef, undef, undef, 0.1);
+    } while &time() < $patience && $child != $self->{'tcp_chld'};
+
+    if ($child == $self->{'tcp_chld'}) {
+      if ($self->{proto} eq "stream") {
+        # We need the socket connected here, in parent
+        # Should be safe to connect because the child finished
+        # within the timeout
+        &{ $do_connect }();
+      }
+      # $ret cannot be set by the child process
+      $ret = !$child_errno;
+    } else {
+      # Time must have run out.
+      # Put that choking client out of its misery
+      kill "KILL", $self->{'tcp_chld'};
+      # Clean off the zombie
+      waitpid($self->{'tcp_chld'}, 0);
+      $ret = 0;
+    }
+    delete $self->{'tcp_chld'};
+    $! = $child_errno;
+  } else {
+    # Otherwise don't waste the resources to fork
+
+    &{ $do_socket }();
+
+    &{ $do_connect_nb }();
+  }
+
+  return $ret;
+}
+
+sub DESTROY {
+  my $self = shift;
+  if ($self->{'proto'} && ($self->{'proto'} eq 'tcp') && $self->{'tcp_chld'}) {
+    # Put that choking client out of its misery
+    kill "KILL", $self->{'tcp_chld'};
+    # Clean off the zombie
+    waitpid($self->{'tcp_chld'}, 0);
+  }
+}
+
+# This writes the given string to the socket and then reads it
+# back.  It returns 1 on success, 0 on failure.
+sub tcp_echo
+{
+  my ($self, $timeout, $pingstring) = @_;
+
+  $timeout = $self->{timeout} if !defined $timeout and $self->{timeout};
+  $pingstring = $self->{pingstring} if !defined $pingstring and $self->{pingstring};
+
+  my $ret = undef;
+  my $time = &time();
+  my $wrstr = $pingstring;
+  my $rdstr = "";
+
+  eval <<'EOM';
+    do {
+      my $rin = "";
+      vec($rin, $self->{fh}->fileno(), 1) = 1;
+
+      my $rout = undef;
+      if($wrstr) {
+        $rout = "";
+        vec($rout, $self->{fh}->fileno(), 1) = 1;
+      }
+
+      if(mselect($rin, $rout, undef, ($time + $timeout) - &time())) {
+
+        if($rout && vec($rout,$self->{fh}->fileno(),1)) {
+          my $num = syswrite($self->{fh}, $wrstr, length $wrstr);
+          if($num) {
+            # If it was a partial write, update and try again.
+            $wrstr = substr($wrstr,$num);
+          } else {
+            # There was an error.
+            $ret = 0;
+          }
+        }
+
+        if(vec($rin,$self->{fh}->fileno(),1)) {
+          my $reply;
+          if(sysread($self->{fh},$reply,length($pingstring)-length($rdstr))) {
+            $rdstr .= $reply;
+            $ret = 1 if $rdstr eq $pingstring;
+          } else {
+            # There was an error.
+            $ret = 0;
+          }
+        }
+
+      }
+    } until &time() > ($time + $timeout) || defined($ret);
+EOM
+
+  return $ret;
+}
+
+# Description: Perform a stream ping.  If the tcp connection isn't
+# already open, it opens it.  It then sends some data and waits for
+# a reply.  It leaves the stream open on exit.
+
+sub ping_stream
+{
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout            # Seconds after which ping times out
+      ) = @_;
+
+  # Open the stream if it's not already open
+  if(!defined $self->{fh}->fileno()) {
+    $self->tcp_connect($ip, $timeout) or return 0;
+  }
+
+  croak "tried to switch servers while stream pinging"
+    if $self->{ip} ne $ip->{addr_in};
+
+  return $self->tcp_echo($timeout, $pingstring);
+}
+
+# Description: opens the stream.  You would do this if you want to
+# separate the overhead of opening the stream from the first ping.
+
+sub open
+{
+  my ($self,
+      $host,              # Host or IP address
+      $timeout,           # Seconds after which open times out
+      $family
+      ) = @_;
+  my $ip;                 # Hash of addr (string), addr_in (packed), family
+  $host = $self->{host} unless defined $host;
+
+  if ($family) {
+    if ($family =~ $qr_family) {
+      if ($family =~ $qr_family4) {
+        $self->{family_local} = AF_INET;
+      } else {
+        $self->{family_local} = $AF_INET6;
+      }
+    } else {
+      croak('Family must be "ipv4" or "ipv6"')
+    }
+  } else {
+    $self->{family_local} = $self->{family};
+  }
+
+  $timeout = $self->{timeout} unless $timeout;
+  $ip = $self->_resolv($host);
+
+  if ($self->{proto} eq "stream") {
+    if (defined($self->{fh}->fileno())) {
+      croak("socket is already open");
+    } else {
+      return () unless $ip;
+      $self->tcp_connect($ip, $timeout);
+    }
+  }
+}
+
+sub _dontfrag {
+  my $self = shift;
+  # bsd solaris
+  my $IP_DONTFRAG = eval { Socket::IP_DONTFRAG() };
+  if ($IP_DONTFRAG) {
+    my $i = 1;
+    setsockopt($self->{fh}, IPPROTO_IP, $IP_DONTFRAG, pack("I*", $i))
+      or croak "error configuring IP_DONTFRAG $!";
+    # Linux needs more: Path MTU Discovery as defined in RFC 1191
+    # For non SOCK_STREAM sockets it is the user's responsibility to packetize
+    # the data in MTU sized chunks and to do the retransmits if necessary.
+    # The kernel will reject packets that are bigger than the known path
+    # MTU if this flag is set (with EMSGSIZE).
+    if ($^O eq 'linux') {
+      my $i = 2; # IP_PMTUDISC_DO
+      setsockopt($self->{fh}, IPPROTO_IP, IP_MTU_DISCOVER, pack("I*", $i))
+        or croak "error configuring IP_MTU_DISCOVER $!";
+    }
+  }
+}
+
+# SO_BINDTODEVICE + IP_TOS
+sub _setopts {
+  my $self = shift;
+  if ($self->{'device'}) {
+    setsockopt($self->{fh}, SOL_SOCKET, SO_BINDTODEVICE, pack("Z*", $self->{'device'}))
+      or croak "error binding to device $self->{'device'} $!";
+  }
+  if ($self->{'tos'}) { # need to re-apply ToS (RT #6706)
+    setsockopt($self->{fh}, IPPROTO_IP, IP_TOS, pack("I*", $self->{'tos'}))
+      or croak "error applying tos to $self->{'tos'} $!";
+  }
+  if ($self->{'dontfrag'}) {
+    $self->_dontfrag;
+  }
+}  
+
+
+# Description:  Perform a udp echo ping.  Construct a message of
+# at least the one-byte sequence number and any additional data bytes.
+# Send the message out and wait for a message to come back.  If we
+# get a message, make sure all of its parts match.  If they do, we are
+# done.  Otherwise go back and wait for the message until we run out
+# of time.  Return the result of our efforts.
+
+use constant UDP_FLAGS => 0; # Nothing special on send or recv
+sub ping_udp
+{
+  my ($self,
+      $ip,                # Hash of addr (string), addr_in (packed), family
+      $timeout            # Seconds after which ping times out
+      ) = @_;
+
+  my ($saddr,             # sockaddr_in with port and ip
+      $ret,               # The return value
+      $msg,               # Message to be echoed
+      $finish_time,       # Time ping should be finished
+      $flush,             # Whether socket needs to be disconnected
+      $connect,           # Whether socket needs to be connected
+      $done,              # Set to 1 when we are done pinging
+      $rbits,             # Read bits, filehandles for reading
+      $nfound,            # Number of ready filehandles found
+      $from_saddr,        # sockaddr_in of sender
+      $from_msg,          # Characters echoed by $host
+      $from_port,         # Port message was echoed from
+      $from_ip            # Packed IP number of sender
+      );
+
+  $saddr = _pack_sockaddr_in($self->{port_num}, $ip);
+  $self->{seq} = ($self->{seq} + 1) % 256;    # Increment sequence
+  $msg = chr($self->{seq}) . $self->{data};   # Add data if any
+
+  socket($self->{fh}, $ip->{family}, SOCK_DGRAM,
+         $self->{proto_num}) ||
+           croak("udp socket error - $!");
+
+  if (defined $self->{local_addr} &&
+      !CORE::bind($self->{fh}, _pack_sockaddr_in(0, $self->{local_addr}))) {
+    croak("udp bind error - $!");
+  }
+
+  $self->_setopts();
+
+  if ($self->{connected}) {
+    if ($self->{connected} ne $saddr) {
+      # Still connected to wrong destination.
+      # Need to flush out the old one.
+      $flush = 1;
+    }
+  } else {
+    # Not connected yet.
+    # Need to connect() before send()
+    $connect = 1;
+  }
+
+  # Have to connect() and send() instead of sendto()
+  # in order to pick up on the ECONNREFUSED setting
+  # from recv() or double send() errno as utilized in
+  # the concept by rdw @ perlmonks.  See:
+  # http://perlmonks.thepen.com/42898.html
+  if ($flush) {
+    # Need to socket() again to flush the descriptor
+    # This will disconnect from the old saddr.
+    socket($self->{fh}, $ip->{family}, SOCK_DGRAM,
+           $self->{proto_num});
+    $self->_setopts();
+  }
+  # Connect the socket if it isn't already connected
+  # to the right destination.
+  if ($flush || $connect) {
+    connect($self->{fh}, $saddr);               # Tie destination to socket
+    $self->{connected} = $saddr;
+  }
+  send($self->{fh}, $msg, UDP_FLAGS);           # Send it
+
+  $rbits = "";
+  vec($rbits, $self->{fh}->fileno(), 1) = 1;
+  $ret = 0;                   # Default to unreachable
+  $done = 0;
+  my $retrans = 0.01;
+  my $factor = $self->{retrans};
+  $finish_time = &time() + $timeout;       # Ping needs to be done by then
+  while (!$done && $timeout > 0)
+  {
+    if ($factor > 1)
+    {
+      $timeout = $retrans if $timeout > $retrans;
+      $retrans*= $factor; # Exponential backoff
+    }
+    $nfound  = mselect((my $rout=$rbits), undef, undef, $timeout); # Wait for response
+    my $why = $!;
+    $timeout = $finish_time - &time();   # Get remaining time
+
+    if (!defined($nfound))  # Hmm, a strange error
+    {
+      $ret = undef;
+      $done = 1;
+    }
+    elsif ($nfound)         # A packet is waiting
+    {
+      $from_msg = "";
+      $from_saddr = recv($self->{fh}, $from_msg, 1500, UDP_FLAGS);
+      if (!$from_saddr) {
+        # For example an unreachable host will make recv() fail.
+        if (!$self->{econnrefused} &&
+            ($! == ECONNREFUSED ||
+             $! == ECONNRESET)) {
+          # "Connection refused" means reachable
+          # Good, continue
+          $ret = 1;
+        }
+        $done = 1;
+      } else {
+        ($from_port, $from_ip) = _unpack_sockaddr_in($from_saddr, $ip->{family});
+        my $addr_in = ref($ip) eq "HASH" ? $ip->{addr_in} : $ip;
+        if (!$source_verify ||
+            (($from_ip eq $addr_in) &&        # Does the packet check out?
+             ($from_port == $self->{port_num}) &&
+             ($from_msg eq $msg)))
+        {
+          $ret = 1;       # It's a winner
+          $done = 1;
+        }
+      }
+    }
+    elsif ($timeout <= 0)              # Oops, timed out
+    {
+      $done = 1;
+    }
+    else
+    {
+      # Send another in case the last one dropped
+      if (send($self->{fh}, $msg, UDP_FLAGS)) {
+        # Another send worked?  The previous udp packet
+        # must have gotten lost or is still in transit.
+        # Hopefully this new packet will arrive safely.
+      } else {
+        if (!$self->{econnrefused} &&
+            $! == ECONNREFUSED) {
+          # "Connection refused" means reachable
+          # Good, continue
+          $ret = 1;
+        }
+        $done = 1;
+      }
+    }
+  }
+  return $ret;
+}
+
+# Description: Send a TCP SYN packet to host specified.
+sub ping_syn
+{
+  my $self = shift;
+  my $host = shift;
+  my $ip = shift;
+  my $start_time = shift;
+  my $stop_time = shift;
+
+  if ($syn_forking) {
+    return $self->ping_syn_fork($host, $ip, $start_time, $stop_time);
+  }
+
+  my $fh = FileHandle->new();
+  my $saddr = _pack_sockaddr_in($self->{port_num}, $ip);
+
+  # Create TCP socket
+  if (!socket ($fh, $ip->{family}, SOCK_STREAM, $self->{proto_num})) {
+    croak("tcp socket error - $!");
+  }
+
+  if (defined $self->{local_addr} &&
+      !CORE::bind($fh, _pack_sockaddr_in(0, $self->{local_addr}))) {
+    croak("tcp bind error - $!");
+  }
+
+  $self->_setopts();
+  # Set O_NONBLOCK property on filehandle
+  $self->socket_blocking_mode($fh, 0);
+
+  # Attempt the non-blocking connect
+  # by just sending the TCP SYN packet
+  if (connect($fh, $saddr)) {
+    # Non-blocking, yet still connected?
+    # Must have connected very quickly,
+    # or else it wasn't very non-blocking.
+    #warn "WARNING: Nonblocking connect connected anyway? ($^O)";
+  } else {
+    # Error occurred connecting.
+    if ($! == EINPROGRESS || ($^O eq 'MSWin32' && $! == EWOULDBLOCK)) {
+      # The connection is just still in progress.
+      # This is the expected condition.
+    } else {
+      # Just save the error and continue on.
+      # The ack() can check the status later.
+      $self->{bad}->{$host} = $!;
+    }
+  }
+
+  my $entry = [ $host, $ip, $fh, $start_time, $stop_time, $self->{port_num} ];
+  $self->{syn}->{$fh->fileno} = $entry;
+  if ($self->{stop_time} < $stop_time) {
+    $self->{stop_time} = $stop_time;
+  }
+  vec($self->{wbits}, $fh->fileno, 1) = 1;
+
+  return 1;
+}
+
+sub ping_syn_fork {
+  my ($self, $host, $ip, $start_time, $stop_time) = @_;
+
+  # Buggy Winsock API doesn't allow nonblocking connect.
+  # Hence, if our OS is Windows, we need to create a separate
+  # process to do the blocking connect attempt.
+  my $pid = fork();
+  if (defined $pid) {
+    if ($pid) {
+      # Parent process
+      my $entry = [ $host, $ip, $pid, $start_time, $stop_time ];
+      $self->{syn}->{$pid} = $entry;
+      if ($self->{stop_time} < $stop_time) {
+        $self->{stop_time} = $stop_time;
+      }
+    } else {
+      # Child process
+      my $saddr = _pack_sockaddr_in($self->{port_num}, $ip);
+
+      # Create TCP socket
+      if (!socket ($self->{fh}, $ip->{family}, SOCK_STREAM, $self->{proto_num})) {
+        croak("tcp socket error - $!");
+      }
+
+      if (defined $self->{local_addr} &&
+          !CORE::bind($self->{fh}, _pack_sockaddr_in(0, $self->{local_addr}))) {
+        croak("tcp bind error - $!");
+      }
+
+      $self->_setopts();
+
+      $!=0;
+      # Try to connect (could take a long time)
+      connect($self->{fh}, $saddr);
+      # Notify parent of connect error status
+      my $err = $!+0;
+      my $wrstr = "$$ $err";
+      # Force to 16 chars including \n
+      $wrstr .= " "x(15 - length $wrstr). "\n";
+      syswrite($self->{fork_wr}, $wrstr, length $wrstr);
+      exit;
+    }
+  } else {
+    # fork() failed?
+    die "fork: $!";
+  }
+  return 1;
+}
+
+# Description: Wait for TCP ACK from host specified
+# from ping_syn above.  If no host is specified, wait
+# for TCP ACK from any of the hosts in the SYN queue.
+sub ack
+{
+  my $self = shift;
+
+  if ($self->{proto} eq "syn") {
+    if ($syn_forking) {
+      my @answer = $self->ack_unfork(shift);
+      return wantarray ? @answer : $answer[0];
+    }
+    my $wbits = "";
+    my $stop_time = 0;
+    if (my $host = shift or $self->{host}) {
+      # Host passed as arg or as option to new
+      $host = $self->{host} unless defined $host;
+      if (exists $self->{bad}->{$host}) {
+        if (!$self->{econnrefused} &&
+            $self->{bad}->{ $host } &&
+            (($! = ECONNREFUSED)>0) &&
+            $self->{bad}->{ $host } eq "$!") {
+          # "Connection refused" means reachable
+          # Good, continue
+        } else {
+          # ECONNREFUSED means no good
+          return ();
+        }
+      }
+      my $host_fd = undef;
+      foreach my $fd (keys %{ $self->{syn} }) {
+        my $entry = $self->{syn}->{$fd};
+        if ($entry->[0] eq $host) {
+          $host_fd = $fd;
+          $stop_time = $entry->[4]
+            || croak("Corrupted SYN entry for [$host]");
+          last;
+        }
+      }
+      croak("ack called on [$host] without calling ping first!")
+        unless defined $host_fd;
+      vec($wbits, $host_fd, 1) = 1;
+    } else {
+      # No $host passed so scan all hosts
+      # Use the latest stop_time
+      $stop_time = $self->{stop_time};
+      # Use all the bits
+      $wbits = $self->{wbits};
+    }
+
+    while ($wbits !~ /^\0*\z/) {
+      my $timeout = $stop_time - &time();
+      # Force a minimum of 10 ms timeout.
+      $timeout = 0.01 if $timeout <= 0.01;
+
+      my $winner_fd = undef;
+      my $wout = $wbits;
+      my $fd = 0;
+      # Do "bad" fds from $wbits first
+      while ($wout !~ /^\0*\z/) {
+        if (vec($wout, $fd, 1)) {
+          # Wipe it from future scanning.
+          vec($wout, $fd, 1) = 0;
+          if (my $entry = $self->{syn}->{$fd}) {
+            if ($self->{bad}->{ $entry->[0] }) {
+              $winner_fd = $fd;
+              last;
+            }
+          }
+        }
+        $fd++;
+      }
+
+      if (defined($winner_fd) or my $nfound = mselect(undef, ($wout=$wbits), undef, $timeout)) {
+        if (defined $winner_fd) {
+          $fd = $winner_fd;
+        } else {
+          # Done waiting for one of the ACKs
+          $fd = 0;
+          # Determine which one
+          while ($wout !~ /^\0*\z/ &&
+                 !vec($wout, $fd, 1)) {
+            $fd++;
+          }
+        }
+        if (my $entry = $self->{syn}->{$fd}) {
+          # Wipe it from future scanning.
+          delete $self->{syn}->{$fd};
+          vec($self->{wbits}, $fd, 1) = 0;
+          vec($wbits, $fd, 1) = 0;
+          if (!$self->{econnrefused} &&
+              $self->{bad}->{ $entry->[0] } &&
+              (($! = ECONNREFUSED)>0) &&
+              $self->{bad}->{ $entry->[0] } eq "$!") {
+            # "Connection refused" means reachable
+            # Good, continue
+          } elsif (getpeername($entry->[2])) {
+            # Connection established to remote host
+            # Good, continue
+          } else {
+            # TCP ACK will never come from this host
+            # because there was an error connecting.
+
+            # This should set $! to the correct error.
+            my $char;
+            sysread($entry->[2],$char,1);
+            # Store the excuse why the connection failed.
+            $self->{bad}->{$entry->[0]} = $!;
+            if (!$self->{econnrefused} &&
+                (($! == ECONNREFUSED) ||
+                 ($! == EAGAIN && $^O =~ /cygwin/i))) {
+              # "Connection refused" means reachable
+              # Good, continue
+            } else {
+              # No good, try the next socket...
+              next;
+            }
+          }
+          # Everything passed okay, return the answer
+          return wantarray ?
+            ($entry->[0], &time() - $entry->[3], $self->ntop($entry->[1]), $entry->[5])
+            : $entry->[0];
+        } else {
+          warn "Corrupted SYN entry: unknown fd [$fd] ready!";
+          vec($wbits, $fd, 1) = 0;
+          vec($self->{wbits}, $fd, 1) = 0;
+        }
+      } elsif (defined $nfound) {
+        # Timed out waiting for ACK
+        foreach my $fd (keys %{ $self->{syn} }) {
+          if (vec($wbits, $fd, 1)) {
+            my $entry = $self->{syn}->{$fd};
+            $self->{bad}->{$entry->[0]} = "Timed out";
+            vec($wbits, $fd, 1) = 0;
+            vec($self->{wbits}, $fd, 1) = 0;
+            delete $self->{syn}->{$fd};
+          }
+        }
+      } else {
+        # Weird error occurred with select()
+        warn("select: $!");
+        $self->{syn} = {};
+        $wbits = "";
+      }
+    }
+  }
+  return ();
+}
+
+sub ack_unfork {
+  my ($self,$host) = @_;
+  my $stop_time = $self->{stop_time};
+  if ($host) {
+    # Host passed as arg
+    if (my $entry = $self->{good}->{$host}) {
+      delete $self->{good}->{$host};
+      return ($entry->[0], &time() - $entry->[3], $self->ntop($entry->[1]));
+    }
+  }
+
+  my $rbits = "";
+  my $timeout;
+
+  if (keys %{ $self->{syn} }) {
+    # Scan all hosts that are left
+    vec($rbits, fileno($self->{fork_rd}), 1) = 1;
+    $timeout = $stop_time - &time();
+    # Force a minimum of 10 ms timeout.
+    $timeout = 0.01 if $timeout < 0.01;
+  } else {
+    # No hosts left to wait for
+    $timeout = 0;
+  }
+
+  if ($timeout > 0) {
+    my $nfound;
+    while ( keys %{ $self->{syn} } and
+           $nfound = mselect((my $rout=$rbits), undef, undef, $timeout)) {
+      # Done waiting for one of the ACKs
+      if (!sysread($self->{fork_rd}, $_, 16)) {
+        # Socket closed, which means all children are done.
+        return ();
+      }
+      my ($pid, $how) = split;
+      if ($pid) {
+        # Flush the zombie
+        waitpid($pid, 0);
+        if (my $entry = $self->{syn}->{$pid}) {
+          # Connection attempt to remote host is done
+          delete $self->{syn}->{$pid};
+          if (!$how || # If there was no error connecting
+              (!$self->{econnrefused} &&
+               $how == ECONNREFUSED)) {  # "Connection refused" means reachable
+            if ($host && $entry->[0] ne $host) {
+              # A good connection, but not the host we need.
+              # Move it from the "syn" hash to the "good" hash.
+              $self->{good}->{$entry->[0]} = $entry;
+              # And wait for the next winner
+              next;
+            }
+            return ($entry->[0], &time() - $entry->[3], $self->ntop($entry->[1]));
+          }
+        } else {
+          # Should never happen
+          die "Unknown ping from pid [$pid]";
+        }
+      } else {
+        die "Empty response from status socket?";
+      }
+    }
+    if (defined $nfound) {
+      # Timed out waiting for ACK status
+    } else {
+      # Weird error occurred with select()
+      warn("select: $!");
+    }
+  }
+  if (my @synners = keys %{ $self->{syn} }) {
+    # Kill all the synners
+    kill 9, @synners;
+    foreach my $pid (@synners) {
+      # Wait for the deaths to finish
+      # Then flush off the zombie
+      waitpid($pid, 0);
+    }
+  }
+  $self->{syn} = {};
+  return ();
+}
+
+# Description:  Tell why the ack() failed
+sub nack {
+  my $self = shift;
+  my $host = shift || croak('Usage> nack($failed_ack_host)');
+  return $self->{bad}->{$host} || undef;
+}
+
+# Description:  Close the connection.
+
+sub close
+{
+  my ($self) = @_;
+
+  if ($self->{proto} eq "syn") {
+    delete $self->{syn};
+  } elsif ($self->{proto} eq "tcp") {
+    # The connection will already be closed
+  } elsif ($self->{proto} eq "external") {
+    # Nothing to close
+  } else {
+    $self->{fh}->close();
+  }
+}
+
+sub port_number {
+   my $self = shift;
+   if(@_) {
+       $self->{port_num} = shift @_;
+       $self->service_check(1);
+   }
+   return $self->{port_num};
+}
+
+sub ntop {
+    my($self, $ip) = @_;
+
+    # Vista doesn't define a inet_ntop.  It has InetNtop instead.
+    # Not following ANSI... priceless.  getnameinfo() is defined
+    # for Windows 2000 and later, so that may be the choice.
+
+    # Any port will work, even undef, but this will work for now.
+    # Socket warns when undef is passed in, but it still works.
+    my $port = getservbyname('echo', 'udp');
+    my $sockaddr = _pack_sockaddr_in($port, $ip);
+    my ($error, $address) = getnameinfo($sockaddr, $NI_NUMERICHOST);
+    croak $error if $error;
+    return $address;
+}
+
+sub wakeonlan {
+  my ($mac_addr, $host, $port) = @_;
+
+  # use the discard service if $port not passed in
+  if (! defined $host) { $host = '255.255.255.255' }
+  if (! defined $port || $port !~ /^\d+$/ ) { $port = 9 }
+
+  require IO::Socket::INET;
+  my $sock = IO::Socket::INET->new(Proto=>'udp') || return undef;
+
+  my $ip_addr = inet_aton($host);
+  my $sock_addr = sockaddr_in($port, $ip_addr);
+  $mac_addr =~ s/://g;
+  my $packet = pack('C6H*', 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, $mac_addr x 16);
+
+  setsockopt($sock, SOL_SOCKET, SO_BROADCAST, 1);
+  send($sock, $packet, 0, $sock_addr);
+  $sock->close;
+
+  return 1;
+}
+
+########################################################
+# DNS hostname resolution
+# return:
+#   $h->{name}    = host - as passed in
+#   $h->{host}    = host - as passed in without :port
+#   $h->{port}    = OPTIONAL - if :port, then value of port
+#   $h->{addr}    = resolved numeric address
+#   $h->{addr_in} = aton/pton result
+#   $h->{family}  = AF_INET/6
+############################
+sub _resolv {
+  my ($self,
+      $name,
+      ) = @_;
+
+  my %h;
+  $h{name} = $name;
+  my $family = $self->{family};
+
+  if (defined($self->{family_local})) {
+    $family = $self->{family_local}
+  }
+
+# START - host:port
+  my $cnt = 0;
+
+  # Count ":"
+  $cnt++ while ($name =~ m/:/g);
+
+  # 0 = hostname or IPv4 address
+  if ($cnt == 0) {
+    $h{host} = $name
+  # 1 = IPv4 address with port
+  } elsif ($cnt == 1) {
+    ($h{host}, $h{port}) = split /:/, $name
+  # >=2 = IPv6 address
+  } elsif ($cnt >= 2) {
+    #IPv6 with port - [2001::1]:port
+    if ($name =~ /^\[.*\]:\d{1,5}$/) {
+      ($h{host}, $h{port}) = split /:([^:]+)$/, $name # split after last :
+    # IPv6 without port
+    } else {
+      $h{host} = $name
+    }
+  }
+
+  # Clean up host
+  $h{host} =~ s/\[//g;
+  $h{host} =~ s/\]//g;
+  # Clean up port
+  if (defined($h{port}) && (($h{port} !~ /^\d{1,5}$/) || ($h{port} < 1) || ($h{port} > 65535))) {
+    croak("Invalid port `$h{port}' in `$name'");
+    return undef;
+  }
+# END - host:port
+
+  # address check
+  # new way
+  if ($Socket_VERSION > 1.94) {
+    my %hints = (
+      family   => $AF_UNSPEC,
+      protocol => IPPROTO_TCP,
+      flags => $AI_NUMERICHOST
+    );
+
+    # numeric address, return
+    my ($err, @getaddr) = Socket::getaddrinfo($h{host}, undef, \%hints);
+    if (defined($getaddr[0])) {
+      $h{addr} = $h{host};
+      $h{family} = $getaddr[0]->{family};
+      if ($h{family} == AF_INET) {
+        (undef, $h{addr_in}, undef, undef) = Socket::unpack_sockaddr_in $getaddr[0]->{addr};
+      } else {
+        (undef, $h{addr_in}, undef, undef) = Socket::unpack_sockaddr_in6 $getaddr[0]->{addr};
+      }
+      return \%h
+    }
+  # old way
+  } else {
+    # numeric address, return
+    my $ret = gethostbyname($h{host});
+    if (defined($ret) && (_inet_ntoa($ret) eq $h{host})) {
+      $h{addr} = $h{host};
+      $h{addr_in} = $ret;
+      $h{family} = AF_INET;
+      return \%h
+    }
+  }
+
+  # resolve
+  # new way
+  if ($Socket_VERSION >= 1.94) {
+    my %hints = (
+      family   => $family,
+      protocol => IPPROTO_TCP
+    );
+
+    my ($err, @getaddr) = Socket::getaddrinfo($h{host}, undef, \%hints);
+    if (defined($getaddr[0])) {
+      my ($err, $address) = Socket::getnameinfo($getaddr[0]->{addr}, $NI_NUMERICHOST, $NIx_NOSERV);
+      if (defined($address)) {
+        $h{addr} = $address;
+        $h{addr} =~ s/\%(.)*$//; # remove %ifID if IPv6
+        $h{family} = $getaddr[0]->{family};
+        if ($h{family} == AF_INET) {
+          (undef, $h{addr_in}, undef, undef) = Socket::unpack_sockaddr_in $getaddr[0]->{addr};
+        } else {
+          (undef, $h{addr_in}, undef, undef) = Socket::unpack_sockaddr_in6 $getaddr[0]->{addr};
+        }
+        return \%h;
+      } else {
+        carp("getnameinfo($getaddr[0]->{addr}) failed - $err");
+        return undef;
+      }
+    } else {
+      warn(sprintf("getaddrinfo($h{host},,%s) failed - $err",
+                    $family == AF_INET ? "AF_INET" : "AF_INET6"));
+      return undef;
+    }
+  # old way
+  } else {
+    if ($family == $AF_INET6) {
+      croak("Socket >= 1.94 required for IPv6 - found Socket $Socket::VERSION");
+      return undef;
+    }
+
+    my @gethost = gethostbyname($h{host});
+    if (defined($gethost[4])) {
+      $h{addr} = inet_ntoa($gethost[4]);
+      $h{addr_in} = $gethost[4];
+      $h{family} = AF_INET;
+      return \%h
+    } else {
+      carp("gethostbyname($h{host}) failed - $^E");
+      return undef;
+    }
+  }
+  return undef;
+}
+
+sub _pack_sockaddr_in($$) {
+  my ($port,
+      $ip,
+      ) = @_;
+
+  my $addr = ref($ip) eq "HASH" ? $ip->{addr_in} : $ip;
+  if (length($addr) <= 4 ) {
+    return Socket::pack_sockaddr_in($port, $addr);
+  } else {
+    return Socket::pack_sockaddr_in6($port, $addr);
+  }
+}
+
+sub _unpack_sockaddr_in($;$) {
+  my ($addr,
+      $family,
+      ) = @_;
+
+  my ($port, $host);
+  if ($family == AF_INET || (!defined($family) and length($addr) <= 16 )) {
+    ($port, $host) = Socket::unpack_sockaddr_in($addr);
+  } else {
+    ($port, $host) = Socket::unpack_sockaddr_in6($addr);
+  }
+  return $port, $host
+}
+
+sub _inet_ntoa {
+  my ($addr
+      ) = @_;
+
+  my $ret;
+  if ($Socket_VERSION >= 1.94) {
+    my ($err, $address) = Socket::getnameinfo($addr, $NI_NUMERICHOST);
+    if (defined($address)) {
+      $ret = $address;
+    } else {
+      carp("getnameinfo($addr) failed - $err");
+    }
+  } else {
+    $ret = inet_ntoa($addr)
+  }
+    
+  return $ret
+}
+
+1;
+__END__
+
+=head1 NAME
+
+Net::Ping - check a remote host for reachability
+
+=head1 SYNOPSIS
+
+    use Net::Ping;
+
+    my $p = Net::Ping->new();
+    print "$host is alive.\n" if $p->ping($host);
+    $p->close();
+
+    my $p = Net::Ping->new("icmp");
+    $p->bind($my_addr); # Specify source interface of pings
+    foreach my $host (@host_array)
+    {
+        print "$host is ";
+        print "NOT " unless $p->ping($host, 2);
+        print "reachable.\n";
+        sleep(1);
+    }
+    $p->close();
+
+    my $p = Net::Ping->new("icmpv6");
+    my $ip = "[fd00:dead:beef::4e]";
+    print "$ip is alive.\n" if $p->ping($ip);
+
+    my $p = Net::Ping->new("tcp", 2);
+    # Try connecting to the www port instead of the echo port
+    $p->port_number(scalar(getservbyname("http", "tcp")));
+    while ($stop_time > time())
+    {
+        print "$host not reachable ", scalar(localtime()), "\n"
+            unless $p->ping($host);
+        sleep(300);
+    }
+    undef($p);
+
+    # Like tcp protocol, but with many hosts
+    my $p = Net::Ping->new("syn");
+    $p->port_number(getservbyname("http", "tcp"));
+    foreach my $host (@host_array) {
+      $p->ping($host);
+    }
+    while (my ($host, $rtt, $ip) = $p->ack) {
+      print "HOST: $host [$ip] ACKed in $rtt seconds.\n";
+    }
+
+    # High precision syntax (requires Time::HiRes)
+    my $p = Net::Ping->new();
+    $p->hires();
+    my ($ret, $duration, $ip) = $p->ping($host, 5.5);
+    printf("$host [ip: $ip] is alive (packet return time: %.2f ms)\n",
+            1000 * $duration)
+      if $ret;
+    $p->close();
+
+    # For backward compatibility
+    print "$host is alive.\n" if pingecho($host);
+
+=head1 DESCRIPTION
+
+This module contains methods to test the reachability of remote
+hosts on a network.  A ping object is first created with optional
+parameters, a variable number of hosts may be pinged multiple
+times and then the connection is closed.
+
+You may choose one of six different protocols to use for the
+ping. The "tcp" protocol is the default. Note that a live remote host
+may still fail to be pingable by one or more of these protocols. For
+example, www.microsoft.com is generally alive but not "icmp" pingable.
+
+With the "tcp" protocol the ping() method attempts to establish a
+connection to the remote host's echo port.  If the connection is
+successfully established, the remote host is considered reachable.  No
+data is actually echoed.  This protocol does not require any special
+privileges but has higher overhead than the "udp" and "icmp" protocols.
+
+Specifying the "udp" protocol causes the ping() method to send a udp
+packet to the remote host's echo port.  If the echoed packet is
+received from the remote host and the received packet contains the
+same data as the packet that was sent, the remote host is considered
+reachable.  This protocol does not require any special privileges.
+It should be borne in mind that, for a udp ping, a host
+will be reported as unreachable if it is not running the
+appropriate echo service.  For Unix-like systems see L<inetd(8)>
+for more information.
+
+If the "icmp" protocol is specified, the ping() method sends an icmp
+echo message to the remote host, which is what the UNIX ping program
+does.  If the echoed message is received from the remote host and
+the echoed information is correct, the remote host is considered
+reachable.  Specifying the "icmp" protocol requires that the program
+be run as root or that the program be setuid to root.
+
+If the "external" protocol is specified, the ping() method attempts to
+use the C<Net::Ping::External> module to ping the remote host.
+C<Net::Ping::External> interfaces with your system's default C<ping>
+utility to perform the ping, and generally produces relatively
+accurate results. If C<Net::Ping::External> if not installed on your
+system, specifying the "external" protocol will result in an error.
+
+If the "syn" protocol is specified, the L</ping> method will only
+send a TCP SYN packet to the remote host then immediately return.
+If the syn packet was sent successfully, it will return a true value,
+otherwise it will return false.  NOTE: Unlike the other protocols,
+the return value does NOT determine if the remote host is alive or
+not since the full TCP three-way handshake may not have completed
+yet.  The remote host is only considered reachable if it receives
+a TCP ACK within the timeout specified.  To begin waiting for the
+ACK packets, use the L</ack> method as explained below.  Use the
+"syn" protocol instead the "tcp" protocol to determine reachability
+of multiple destinations simultaneously by sending parallel TCP
+SYN packets.  It will not block while testing each remote host.
+This protocol does not require any special privileges.
+
+=head2 Functions
+
+=over 4
+
+=item Net::Ping->new([proto, timeout, bytes, device, tos, ttl, family,
+                      host, port, bind, gateway, retrans, pingstring,
+                      source_verify econnrefused dontfrag
+                      IPV6_USE_MIN_MTU IPV6_RECVPATHMTU])
+X<new>
+
+Create a new ping object.  All of the parameters are optional and can
+be passed as hash ref.  All options besides the first 7 must be passed
+as hash ref.
+
+C<proto> specifies the protocol to use when doing a ping.  The current
+choices are "tcp", "udp", "icmp", "icmpv6", "stream", "syn", or
+"external".  The default is "tcp".
+
+If a C<timeout> in seconds is provided, it is used
+when a timeout is not given to the ping() method (below).  The timeout
+must be greater than 0 and the default, if not specified, is 5 seconds.
+
+If the number of data bytes (C<bytes>) is given, that many data bytes
+are included in the ping packet sent to the remote host. The number of
+data bytes is ignored if the protocol is "tcp".  The minimum (and
+default) number of data bytes is 1 if the protocol is "udp" and 0
+otherwise.  The maximum number of data bytes that can be specified is
+65535, but staying below the MTU (1472 bytes for ICMP) is recommended.
+Many small devices cannot deal with fragmented ICMP packets.
+
+If C<device> is given, this device is used to bind the source endpoint
+before sending the ping packet.  I believe this only works with
+superuser privileges and with udp and icmp protocols at this time.
+
+If <tos> is given, this ToS is configured into the socket.
+
+For icmp, C<ttl> can be specified to set the TTL of the outgoing packet.
+
+Valid C<family> values for IPv4:
+
+   4, v4, ip4, ipv4, AF_INET (constant)
+
+Valid C<family> values for IPv6:
+
+   6, v6, ip6, ipv6, AF_INET6 (constant)
+
+The C<host> argument implicitly specifies the family if the family
+argument is not given.
+
+The C<port> argument is only valid for a udp, tcp or stream ping, and will not
+do what you think it does. ping returns true when we get a "Connection refused"!
+The default is the echo port.
+
+The C<bind> argument specifies the local_addr to bind to.
+By specifying a bind argument you don't need the bind method.
+
+The C<gateway> argument is only valid for IPv6, and requires a IPv6
+address.
+
+The C<retrans> argument the exponential backoff rate, default 1.2.
+It matches the $def_factor global.
+
+The C<dontfrag> argument sets the IP_DONTFRAG bit, but note that
+IP_DONTFRAG is not yet defined by Socket, and not available on many
+systems. Then it is ignored. On linux it also sets IP_MTU_DISCOVER to
+IP_PMTUDISC_DO but need we don't chunk oversized packets. You need to
+set $data_size manually.
+
+=item $p->ping($host [, $timeout [, $family]]);
+X<ping>
+
+Ping the remote host and wait for a response.  $host can be either the
+hostname or the IP number of the remote host.  The optional timeout
+must be greater than 0 seconds and defaults to whatever was specified
+when the ping object was created.  Returns a success flag.  If the
+hostname cannot be found or there is a problem with the IP number, the
+success flag returned will be undef.  Otherwise, the success flag will
+be 1 if the host is reachable and 0 if it is not.  For most practical
+purposes, undef and 0 and can be treated as the same case.  In array
+context, the elapsed time as well as the string form of the ip the
+host resolved to are also returned.  The elapsed time value will
+be a float, as returned by the Time::HiRes::time() function, if hires()
+has been previously called, otherwise it is returned as an integer.
+
+=item $p->source_verify( { 0 | 1 } );
+X<source_verify>
+
+Allows source endpoint verification to be enabled or disabled.
+This is useful for those remote destinations with multiples
+interfaces where the response may not originate from the same
+endpoint that the original destination endpoint was sent to.
+This only affects udp and icmp protocol pings.
+
+This is enabled by default.
+
+=item $p->service_check( { 0 | 1 } );
+X<service_check>
+
+Set whether or not the connect behavior should enforce
+remote service availability as well as reachability.  Normally,
+if the remote server reported ECONNREFUSED, it must have been
+reachable because of the status packet that it reported.
+With this option enabled, the full three-way tcp handshake
+must have been established successfully before it will
+claim it is reachable.  NOTE:  It still does nothing more
+than connect and disconnect.  It does not speak any protocol
+(i.e., HTTP or FTP) to ensure the remote server is sane in
+any way.  The remote server CPU could be grinding to a halt
+and unresponsive to any clients connecting, but if the kernel
+throws the ACK packet, it is considered alive anyway.  To
+really determine if the server is responding well would be
+application specific and is beyond the scope of Net::Ping.
+For udp protocol, enabling this option demands that the
+remote server replies with the same udp data that it was sent
+as defined by the udp echo service.
+
+This affects the "udp", "tcp", and "syn" protocols.
+
+This is disabled by default.
+
+=item $p->tcp_service_check( { 0 | 1 } );
+X<tcp_service_check>
+
+Deprecated method, but does the same as service_check() method.
+
+=item $p->hires( { 0 | 1 } );
+X<hires>
+
+With 1 causes this module to use Time::HiRes module, allowing milliseconds
+to be returned by subsequent calls to ping().
+
+=item $p->time
+X<time>
+
+The current time, hires or not.
+
+=item $p->socket_blocking_mode( $fh, $mode );
+X<socket_blocking_mode>
+
+Sets or clears the O_NONBLOCK flag on a file handle.
+
+=item $p->IPV6_USE_MIN_MTU
+X<IPV6_USE_MIN_MTU>
+
+With argument sets the option.
+Without returns the option value.
+
+=item $p->IPV6_RECVPATHMTU
+X<IPV6_RECVPATHMTU>
+
+Notify an according IPv6 MTU.
+
+With argument sets the option.
+Without returns the option value.
+
+=item $p->IPV6_HOPLIMIT
+X<IPV6_HOPLIMIT>
+
+With argument sets the option.
+Without returns the option value.
+
+=item $p->IPV6_REACHCONF I<NYI>
+X<IPV6_REACHCONF>
+
+Sets ipv6 reachability
+IPV6_REACHCONF was removed in RFC3542. ping6 -R supports it.
+IPV6_REACHCONF requires root/admin permissions.
+
+With argument sets the option.
+Without returns the option value.
+
+Not yet implemented.
+
+=item $p->bind($local_addr);
+X<bind>
+
+Sets the source address from which pings will be sent.  This must be
+the address of one of the interfaces on the local host.  $local_addr
+may be specified as a hostname or as a text IP address such as
+"192.168.1.1".
+
+If the protocol is set to "tcp", this method may be called any
+number of times, and each call to the ping() method (below) will use
+the most recent $local_addr.  If the protocol is "icmp" or "udp",
+then bind() must be called at most once per object, and (if it is
+called at all) must be called before the first call to ping() for that
+object.
+
+The bind() call can be omitted when specifying the C<bind> option to
+new().
+
+=item $p->message_type([$ping_type]);
+X<message_type>
+
+When you are using the "icmp" protocol, this call permit to change the
+message type to 'echo' or 'timestamp' (only for IPv4, see RFC 792).
+
+Without argument, it returns the currently used icmp protocol message type.
+By default, it returns 'echo'.
+
+=item $p->open($host);
+X<open>
+
+When you are using the "stream" protocol, this call pre-opens the
+tcp socket.  It's only necessary to do this if you want to
+provide a different timeout when creating the connection, or
+remove the overhead of establishing the connection from the
+first ping.  If you don't call C<open()>, the connection is
+automatically opened the first time C<ping()> is called.
+This call simply does nothing if you are using any protocol other
+than stream.
+
+The $host argument can be omitted when specifying the C<host> option to
+new().
+
+=item $p->ack( [ $host ] );
+X<ack>
+
+When using the "syn" protocol, use this method to determine
+the reachability of the remote host.  This method is meant
+to be called up to as many times as ping() was called.  Each
+call returns the host (as passed to ping()) that came back
+with the TCP ACK.  The order in which the hosts are returned
+may not necessarily be the same order in which they were
+SYN queued using the ping() method.  If the timeout is
+reached before the TCP ACK is received, or if the remote
+host is not listening on the port attempted, then the TCP
+connection will not be established and ack() will return
+undef.  In list context, the host, the ack time, the dotted ip 
+string, and the port number will be returned instead of just the host.
+If the optional C<$host> argument is specified, the return
+value will be pertaining to that host only.
+This call simply does nothing if you are using any protocol
+other than "syn".
+
+When L</new> had a host option, this host will be used.
+Without C<$host> argument, all hosts are scanned.
+
+=item $p->nack( $failed_ack_host );
+X<nack>
+
+The reason that C<host $failed_ack_host> did not receive a
+valid ACK.  Useful to find out why when C<ack($fail_ack_host)>
+returns a false value.
+
+=item $p->ack_unfork($host)
+X<ack_unfork>
+
+The variant called by L</ack> with the "syn" protocol and C<$syn_forking>
+enabled.
+
+=item $p->ping_icmp([$host, $timeout, $family])
+X<ping_icmp>
+
+The L</ping> method used with the icmp protocol.
+
+=item $p->ping_icmpv6([$host, $timeout, $family])
+X<ping_icmpv6>
+
+The L</ping> method used with the icmpv6 protocol.
+
+=item $p->ping_stream([$host, $timeout, $family])
+X<ping_stream>
+
+The L</ping> method used with the stream protocol.
+
+Perform a stream ping.  If the tcp connection isn't
+already open, it opens it.  It then sends some data and waits for
+a reply.  It leaves the stream open on exit.
+
+=item $p->ping_syn([$host, $ip, $start_time, $stop_time])
+X<ping_syn>
+
+The L</ping> method used with the syn protocol.
+Sends a TCP SYN packet to host specified.
+
+=item $p->ping_syn_fork([$host, $timeout, $family])
+X<ping_syn_fork>
+
+The L</ping> method used with the forking syn protocol.
+
+=item $p->ping_tcp([$host, $timeout, $family])
+X<ping_tcp>
+
+The L</ping> method used with the tcp protocol.
+
+=item $p->ping_udp([$host, $timeout, $family])
+X<ping_udp>
+
+The L</ping> method used with the udp protocol.
+
+Perform a udp echo ping.  Construct a message of
+at least the one-byte sequence number and any additional data bytes.
+Send the message out and wait for a message to come back.  If we
+get a message, make sure all of its parts match.  If they do, we are
+done.  Otherwise go back and wait for the message until we run out
+of time.  Return the result of our efforts.
+
+=item $p->ping_external([$host, $timeout, $family])
+X<ping_external>
+
+The L</ping> method used with the external protocol.
+Uses L<Net::Ping::External> to do an external ping.
+
+=item $p->tcp_connect([$ip, $timeout])
+X<tcp_connect>
+
+Initiates a TCP connection, for a tcp ping.
+
+=item $p->tcp_echo([$ip, $timeout, $pingstring])
+X<tcp_echo>
+
+Performs a TCP echo.
+It writes the given string to the socket and then reads it
+back.  It returns 1 on success, 0 on failure.
+
+=item $p->close();
+X<close>
+
+Close the network connection for this ping object.  The network
+connection is also closed by "undef $p".  The network connection is
+automatically closed if the ping object goes out of scope (e.g. $p is
+local to a subroutine and you leave the subroutine).
+
+=item $p->port_number([$port_number])
+X<port_number>
+
+When called with a port number, the port number used to ping is set to
+C<$port_number> rather than using the echo port.  It also has the effect
+of calling C<$p-E<gt>service_check(1)> causing a ping to return a successful
+response only if that specific port is accessible.  This function returns
+the value of the port that L</ping> will connect to.
+
+=item $p->mselect
+X<mselect>
+
+A C<select()> wrapper that compensates for platform
+peculiarities.
+
+=item $p->ntop
+X<ntop>
+
+Platform abstraction over C<inet_ntop()>
+
+=item $p->checksum($msg)
+X<checksum>
+
+Do a checksum on the message.  Basically sum all of
+the short words and fold the high order bits into the low order bits.
+
+=item $p->icmp_result
+X<icmp_result>
+
+Returns a list of addr, type, subcode.
+
+=item pingecho($host [, $timeout]);
+X<pingecho>
+
+To provide backward compatibility with the previous version of
+L<Net::Ping>, a C<pingecho()> subroutine is available with the same
+functionality as before.  C<pingecho()> uses the tcp protocol.  The
+return values and parameters are the same as described for the L</ping>
+method.  This subroutine is obsolete and may be removed in a future
+version of L<Net::Ping>.
+
+=item wakeonlan($mac, [$host, [$port]])
+X<wakeonlan>
+
+Emit the popular wake-on-lan magic udp packet to wake up a local
+device.  See also L<Net::Wake>, but this has the mac address as 1st arg.
+C<$host> should be the local gateway. Without it will broadcast.
+
+Default host: '255.255.255.255'
+Default port: 9
+
+  perl -MNet::Ping=wakeonlan -e'wakeonlan "e0:69:95:35:68:d2"'
+
+=back
+
+=head1 NOTES
+
+There will be less network overhead (and some efficiency in your
+program) if you specify either the udp or the icmp protocol.  The tcp
+protocol will generate 2.5 times or more traffic for each ping than
+either udp or icmp.  If many hosts are pinged frequently, you may wish
+to implement a small wait (e.g. 25ms or more) between each ping to
+avoid flooding your network with packets.
+
+The icmp and icmpv6 protocols requires that the program be run as root
+or that it be setuid to root.  The other protocols do not require
+special privileges, but not all network devices implement tcp or udp
+echo.
+
+Local hosts should normally respond to pings within milliseconds.
+However, on a very congested network it may take up to 3 seconds or
+longer to receive an echo packet from the remote host.  If the timeout
+is set too low under these conditions, it will appear that the remote
+host is not reachable (which is almost the truth).
+
+Reachability doesn't necessarily mean that the remote host is actually
+functioning beyond its ability to echo packets.  tcp is slightly better
+at indicating the health of a system than icmp because it uses more
+of the networking stack to respond.
+
+Because of a lack of anything better, this module uses its own
+routines to pack and unpack ICMP packets.  It would be better for a
+separate module to be written which understands all of the different
+kinds of ICMP packets.
+
+=head1 INSTALL
+
+The latest source tree is available via git:
+
+  git clone https://github.com/rurban/Net-Ping.git
+  cd Net-Ping
+
+The tarball can be created as follows:
+
+  perl Makefile.PL ; make ; make dist
+
+The latest Net::Ping releases are included in cperl and perl5.
+
+=head1 BUGS
+
+For a list of known issues, visit:
+
+L<https://rt.cpan.org/NoAuth/Bugs.html?Dist=Net-Ping>
+and
+L<https://github.com/rurban/Net-Ping/issues>
+
+To report a new bug, visit:
+
+L<https://github.com/rurban/Net-Ping/issues>
+
+=head1 AUTHORS
+
+  Current maintainers:
+    perl11 (for cperl, with IPv6 support and more)
+    p5p    (for perl5)
+
+  Previous maintainers:
+    bbb@cpan.org (Rob Brown)
+    Steve Peters
+
+  External protocol:
+    colinm@cpan.org (Colin McMillen)
+
+  Stream protocol:
+    bronson@trestle.com (Scott Bronson)
+
+  Wake-on-lan:
+    1999-2003 Clinton Wong
+
+  Original pingecho():
+    karrer@bernina.ethz.ch (Andreas Karrer)
+    pmarquess@bfsec.bt.co.uk (Paul Marquess)
+
+  Original Net::Ping author:
+    mose@ns.ccsn.edu (Russell Mosemann)
+
+=head1 COPYRIGHT
+
+Copyright (c) 2017-2020, Reini Urban.  All rights reserved.
+
+Copyright (c) 2016, cPanel Inc.  All rights reserved.
+
+Copyright (c) 2012, Steve Peters.  All rights reserved.
+
+Copyright (c) 2002-2003, Rob Brown.  All rights reserved.
+
+Copyright (c) 2001, Colin McMillen.  All rights reserved.
+
+This program is free software; you may redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut

git/usr/share/perl5/core_perl/Net/SMTP.pm

@@ -0,0 +1,1065 @@
+# Net::SMTP.pm
+#
+# Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+# Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::SMTP;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use IO::Socket;
+use Net::Cmd;
+use Net::Config;
+use Socket;
+
+our $VERSION = "3.15";
+
+# Code for detecting if we can use SSL
+my $ssl_class = eval {
+  require IO::Socket::SSL;
+  # first version with default CA on most platforms
+  no warnings 'numeric';
+  IO::Socket::SSL->VERSION(2.007);
+} && 'IO::Socket::SSL';
+
+my $nossl_warn = !$ssl_class &&
+  'To use SSL please install IO::Socket::SSL with version>=2.007';
+
+# Code for detecting if we can use IPv6
+my $family_key = 'Domain';
+my $inet6_class = eval {
+  require IO::Socket::IP;
+  no warnings 'numeric';
+  IO::Socket::IP->VERSION(0.25) || die;
+  $family_key = 'Family';
+} && 'IO::Socket::IP' || eval {
+  require IO::Socket::INET6;
+  no warnings 'numeric';
+  IO::Socket::INET6->VERSION(2.62);
+} && 'IO::Socket::INET6';
+
+sub can_ssl   { $ssl_class };
+sub can_inet6 { $inet6_class };
+
+our @ISA = ('Net::Cmd', $inet6_class || 'IO::Socket::INET');
+
+sub new {
+  my $self = shift;
+  my $type = ref($self) || $self;
+  my ($host, %arg);
+  if (@_ % 2) {
+    $host = shift;
+    %arg  = @_;
+  }
+  else {
+    %arg  = @_;
+    $host = delete $arg{Host};
+  }
+
+  if ($arg{SSL}) {
+    # SSL from start
+    die $nossl_warn if !$ssl_class;
+    $arg{Port} ||= 465;
+  }
+
+  my $hosts = defined $host ? $host : $NetConfig{smtp_hosts};
+  my $obj;
+
+  $arg{Timeout} = 120 if ! defined $arg{Timeout};
+
+  foreach my $h (@{ref($hosts) ? $hosts : [$hosts]}) {
+    $obj = $type->SUPER::new(
+      PeerAddr => ($host = $h),
+      PeerPort => $arg{Port} || 'smtp(25)',
+      LocalAddr => $arg{LocalAddr},
+      LocalPort => $arg{LocalPort},
+      $family_key => $arg{Domain} || $arg{Family},
+      Proto     => 'tcp',
+      Timeout   => $arg{Timeout}
+      )
+      and last;
+  }
+
+  return
+    unless defined $obj;
+
+  ${*$obj}{'net_smtp_arg'} = \%arg;
+  ${*$obj}{'net_smtp_host'} = $host;
+
+  if ($arg{SSL}) {
+    Net::SMTP::_SSL->start_SSL($obj,%arg)
+      or return;
+  }
+
+  $obj->autoflush(1);
+
+  $obj->debug(exists $arg{Debug} ? $arg{Debug} : undef);
+
+  unless ($obj->response() == CMD_OK) {
+    my $err = ref($obj) . ": " . $obj->code . " " . $obj->message;
+    $obj->close();
+    $@ = $err;
+    return;
+  }
+
+  ${*$obj}{'net_smtp_exact_addr'} = $arg{ExactAddresses};
+
+  (${*$obj}{'net_smtp_banner'}) = $obj->message;
+  (${*$obj}{'net_smtp_domain'}) = $obj->message =~ /\A\s*(\S+)/;
+
+  if (!exists $arg{SendHello} || $arg{SendHello}) {
+    unless ($obj->hello($arg{Hello} || "")) {
+      my $err = ref($obj) . ": " . $obj->code . " " . $obj->message;
+      $obj->close();
+      $@ = $err;
+      return;
+    }
+  }
+
+  $obj;
+}
+
+
+sub host {
+  my $me = shift;
+  ${*$me}{'net_smtp_host'};
+}
+
+##
+## User interface methods
+##
+
+
+sub banner {
+  my $me = shift;
+
+  return ${*$me}{'net_smtp_banner'} || undef;
+}
+
+
+sub domain {
+  my $me = shift;
+
+  return ${*$me}{'net_smtp_domain'} || undef;
+}
+
+
+sub etrn {
+  my $self = shift;
+  defined($self->supports('ETRN', 500, ["Command unknown: 'ETRN'"]))
+    && $self->_ETRN(@_);
+}
+
+
+sub auth {
+  my ($self, $username, $password) = @_;
+
+  eval {
+    require MIME::Base64;
+    require Authen::SASL;
+  } or $self->set_status(500, ["Need MIME::Base64 and Authen::SASL todo auth"]), return 0;
+
+  my $mechanisms = $self->supports('AUTH', 500, ["Command unknown: 'AUTH'"]);
+  return unless defined $mechanisms;
+
+  my $sasl;
+
+  if (ref($username) and UNIVERSAL::isa($username, 'Authen::SASL')) {
+    $sasl = $username;
+    my $requested_mechanisms = $sasl->mechanism();
+    if (! defined($requested_mechanisms) || $requested_mechanisms eq '') {
+      $sasl->mechanism($mechanisms);
+    }
+  }
+  else {
+    die "auth(username, password)" if not length $username;
+    $sasl = Authen::SASL->new(
+      mechanism => $mechanisms,
+      callback  => {
+        user     => $username,
+        pass     => $password,
+        authname => $username,
+      },
+      debug => $self->debug
+    );
+  }
+
+  my $client;
+  my $str;
+  do {
+    if ($client) {
+      # $client mechanism failed, so we need to exclude this mechanism from list
+      my $failed_mechanism = $client->mechanism;
+      return unless defined $failed_mechanism;
+      $self->debug_text("Auth mechanism failed: $failed_mechanism")
+        if $self->debug;
+      $mechanisms =~ s/\b\Q$failed_mechanism\E\b//;
+      return unless $mechanisms =~ /\S/;
+      $sasl->mechanism($mechanisms);
+    }
+    
+    # We should probably allow the user to pass the host, but I don't
+    # currently know and SASL mechanisms that are used by smtp that need it
+
+    $client = $sasl->client_new('smtp', ${*$self}{'net_smtp_host'}, 0);
+    $str    = $client->client_start;
+  } while (!defined $str);
+
+  # We don't support sasl mechanisms that encrypt the socket traffic.
+  # todo that we would really need to change the ISA hierarchy
+  # so we don't inherit from IO::Socket, but instead hold it in an attribute
+
+  my @cmd = ("AUTH", $client->mechanism);
+  my $code;
+
+  push @cmd, MIME::Base64::encode_base64($str, '')
+    if defined $str and length $str;
+
+  while (($code = $self->command(@cmd)->response()) == CMD_MORE) {
+    my $str2 = MIME::Base64::decode_base64(($self->message)[0]);
+    $self->debug_print(0, "(decoded) " . $str2 . "\n") if $self->debug;
+
+    $str = $client->client_step($str2);
+    @cmd = (
+      MIME::Base64::encode_base64($str, '')
+    );
+
+    $self->debug_print(1, "(decoded) " . $str . "\n") if $self->debug;
+  }
+
+  $code == CMD_OK;
+}
+
+
+sub hello {
+  my $me     = shift;
+  my $domain = shift || "localhost.localdomain";
+  my $ok     = $me->_EHLO($domain);
+  my @msg    = $me->message;
+
+  if ($ok) {
+    my $h = ${*$me}{'net_smtp_esmtp'} = {};
+    foreach my $ln (@msg) {
+      $h->{uc $1} = $2
+        if $ln =~ /([-\w]+)\b[= \t]*([^\n]*)/;
+    }
+  }
+  elsif ($me->status == CMD_ERROR) {
+    @msg = $me->message
+      if $ok = $me->_HELO($domain);
+  }
+
+  return unless $ok;
+  ${*$me}{net_smtp_hello_domain} = $domain;
+
+  $msg[0] =~ /\A\s*(\S+)/;
+  return ($1 || " ");
+}
+
+sub starttls {
+  my $self = shift;
+  $ssl_class or die $nossl_warn;
+  $self->_STARTTLS or return;
+  Net::SMTP::_SSL->start_SSL($self,
+    %{ ${*$self}{'net_smtp_arg'} }, # (ssl) args given in new
+    @_   # more (ssl) args
+  ) or return;
+
+  # another hello after starttls to read new ESMTP capabilities
+  return $self->hello(${*$self}{net_smtp_hello_domain});
+}
+
+
+sub supports {
+  my $self = shift;
+  my $cmd  = uc shift;
+  return ${*$self}{'net_smtp_esmtp'}->{$cmd}
+    if exists ${*$self}{'net_smtp_esmtp'}->{$cmd};
+  $self->set_status(@_)
+    if @_;
+  return;
+}
+
+
+sub _addr {
+  my $self = shift;
+  my $addr = shift;
+  $addr = "" unless defined $addr;
+
+  if (${*$self}{'net_smtp_exact_addr'}) {
+    return $1 if $addr =~ /^\s*(<.*>)\s*$/s;
+  }
+  else {
+    return $1 if $addr =~ /(<[^>]*>)/;
+    $addr =~ s/^\s+|\s+$//sg;
+  }
+
+  "<$addr>";
+}
+
+
+sub mail {
+  my $me   = shift;
+  my $addr = _addr($me, shift);
+  my $opts = "";
+
+  if (@_) {
+    my %opt = @_;
+    my ($k, $v);
+
+    if (exists ${*$me}{'net_smtp_esmtp'}) {
+      my $esmtp = ${*$me}{'net_smtp_esmtp'};
+
+      if (defined($v = delete $opt{Size})) {
+        if (exists $esmtp->{SIZE}) {
+          $opts .= sprintf " SIZE=%d", $v + 0;
+        }
+        else {
+          carp 'Net::SMTP::mail: SIZE option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{Return})) {
+        if (exists $esmtp->{DSN}) {
+          $opts .= " RET=" . ((uc($v) eq "FULL") ? "FULL" : "HDRS");
+        }
+        else {
+          carp 'Net::SMTP::mail: DSN option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{Bits})) {
+        if ($v eq "8") {
+          if (exists $esmtp->{'8BITMIME'}) {
+            $opts .= " BODY=8BITMIME";
+          }
+          else {
+            carp 'Net::SMTP::mail: 8BITMIME option not supported by host';
+          }
+        }
+        elsif ($v eq "binary") {
+          if (exists $esmtp->{'BINARYMIME'} && exists $esmtp->{'CHUNKING'}) {
+            $opts .= " BODY=BINARYMIME";
+            ${*$me}{'net_smtp_chunking'} = 1;
+          }
+          else {
+            carp 'Net::SMTP::mail: BINARYMIME option not supported by host';
+          }
+        }
+        elsif (exists $esmtp->{'8BITMIME'} or exists $esmtp->{'BINARYMIME'}) {
+          $opts .= " BODY=7BIT";
+        }
+        else {
+          carp 'Net::SMTP::mail: 8BITMIME and BINARYMIME options not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{Transaction})) {
+        if (exists $esmtp->{CHECKPOINT}) {
+          $opts .= " TRANSID=" . _addr($me, $v);
+        }
+        else {
+          carp 'Net::SMTP::mail: CHECKPOINT option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{Envelope})) {
+        if (exists $esmtp->{DSN}) {
+          $v =~ s/([^\041-\176]|=|\+)/sprintf "+%02X", ord($1)/sge;
+          $opts .= " ENVID=$v";
+        }
+        else {
+          carp 'Net::SMTP::mail: DSN option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{ENVID})) {
+
+        # expected to be in a format as required by RFC 3461, xtext-encoded
+        if (exists $esmtp->{DSN}) {
+          $opts .= " ENVID=$v";
+        }
+        else {
+          carp 'Net::SMTP::mail: DSN option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{AUTH})) {
+
+        # expected to be in a format as required by RFC 2554,
+        # rfc2821-quoted and xtext-encoded, or <>
+        if (exists $esmtp->{AUTH}) {
+          $v = '<>' if !defined($v) || $v eq '';
+          $opts .= " AUTH=$v";
+        }
+        else {
+          carp 'Net::SMTP::mail: AUTH option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{XVERP})) {
+        if (exists $esmtp->{'XVERP'}) {
+          $opts .= " XVERP";
+        }
+        else {
+          carp 'Net::SMTP::mail: XVERP option not supported by host';
+        }
+      }
+
+      carp 'Net::SMTP::recipient: unknown option(s) ' . join(" ", keys %opt) . ' - ignored'
+        if scalar keys %opt;
+    }
+    else {
+      carp 'Net::SMTP::mail: ESMTP not supported by host - options discarded :-(';
+    }
+  }
+
+  $me->_MAIL("FROM:" . $addr . $opts);
+}
+
+
+sub send          { my $me = shift; $me->_SEND("FROM:" . _addr($me, $_[0])) }
+sub send_or_mail  { my $me = shift; $me->_SOML("FROM:" . _addr($me, $_[0])) }
+sub send_and_mail { my $me = shift; $me->_SAML("FROM:" . _addr($me, $_[0])) }
+
+
+sub reset {
+  my $me = shift;
+
+  $me->dataend()
+    if (exists ${*$me}{'net_smtp_lastch'});
+
+  $me->_RSET();
+}
+
+
+sub recipient {
+  my $smtp     = shift;
+  my $opts     = "";
+  my $skip_bad = 0;
+
+  if (@_ && ref($_[-1])) {
+    my %opt = %{pop(@_)};
+    my $v;
+
+    $skip_bad = delete $opt{'SkipBad'};
+
+    if (exists ${*$smtp}{'net_smtp_esmtp'}) {
+      my $esmtp = ${*$smtp}{'net_smtp_esmtp'};
+
+      if (defined($v = delete $opt{Notify})) {
+        if (exists $esmtp->{DSN}) {
+          $opts .= " NOTIFY=" . join(",", map { uc $_ } @$v);
+        }
+        else {
+          carp 'Net::SMTP::recipient: DSN option not supported by host';
+        }
+      }
+
+      if (defined($v = delete $opt{ORcpt})) {
+        if (exists $esmtp->{DSN}) {
+          $opts .= " ORCPT=" . $v;
+        }
+        else {
+          carp 'Net::SMTP::recipient: DSN option not supported by host';
+        }
+      }
+
+      carp 'Net::SMTP::recipient: unknown option(s) ' . join(" ", keys %opt) . ' - ignored'
+        if scalar keys %opt;
+    }
+    elsif (%opt) {
+      carp 'Net::SMTP::recipient: ESMTP not supported by host - options discarded :-(';
+    }
+  }
+
+  my @ok;
+  foreach my $addr (@_) {
+    if ($smtp->_RCPT("TO:" . _addr($smtp, $addr) . $opts)) {
+      push(@ok, $addr) if $skip_bad;
+    }
+    elsif (!$skip_bad) {
+      return 0;
+    }
+  }
+
+  return $skip_bad ? @ok : 1;
+}
+
+BEGIN {
+  *to  = \&recipient;
+  *cc  = \&recipient;
+  *bcc = \&recipient;
+}
+
+
+sub data {
+  my $me = shift;
+
+  if (exists ${*$me}{'net_smtp_chunking'}) {
+    carp 'Net::SMTP::data: CHUNKING extension in use, must call bdat instead';
+  }
+  else {
+    my $ok = $me->_DATA() && $me->datasend(@_);
+
+    $ok && @_
+      ? $me->dataend
+      : $ok;
+  }
+}
+
+
+sub bdat {
+  my $me = shift;
+
+  if (exists ${*$me}{'net_smtp_chunking'}) {
+    my $data = shift;
+
+    $me->_BDAT(length $data)
+      && $me->rawdatasend($data)
+      && $me->response() == CMD_OK;
+  }
+  else {
+    carp 'Net::SMTP::bdat: CHUNKING extension is not in use, call data instead';
+  }
+}
+
+
+sub bdatlast {
+  my $me = shift;
+
+  if (exists ${*$me}{'net_smtp_chunking'}) {
+    my $data = shift;
+
+    $me->_BDAT(length $data, "LAST")
+      && $me->rawdatasend($data)
+      && $me->response() == CMD_OK;
+  }
+  else {
+    carp 'Net::SMTP::bdat: CHUNKING extension is not in use, call data instead';
+  }
+}
+
+
+sub datafh {
+  my $me = shift;
+  return unless $me->_DATA();
+  return $me->tied_fh;
+}
+
+
+sub expand {
+  my $me = shift;
+
+  $me->_EXPN(@_)
+    ? ($me->message)
+    : ();
+}
+
+
+sub verify { shift->_VRFY(@_) }
+
+
+sub help {
+  my $me = shift;
+
+  $me->_HELP(@_)
+    ? scalar $me->message
+    : undef;
+}
+
+
+sub quit {
+  my $me = shift;
+
+  $me->_QUIT;
+  $me->close;
+}
+
+
+sub DESTROY {
+
+  # ignore
+}
+
+##
+## RFC821 commands
+##
+
+
+sub _EHLO { shift->command("EHLO", @_)->response() == CMD_OK }
+sub _HELO { shift->command("HELO", @_)->response() == CMD_OK }
+sub _MAIL { shift->command("MAIL", @_)->response() == CMD_OK }
+sub _RCPT { shift->command("RCPT", @_)->response() == CMD_OK }
+sub _SEND { shift->command("SEND", @_)->response() == CMD_OK }
+sub _SAML { shift->command("SAML", @_)->response() == CMD_OK }
+sub _SOML { shift->command("SOML", @_)->response() == CMD_OK }
+sub _VRFY { shift->command("VRFY", @_)->response() == CMD_OK }
+sub _EXPN { shift->command("EXPN", @_)->response() == CMD_OK }
+sub _HELP { shift->command("HELP", @_)->response() == CMD_OK }
+sub _RSET { shift->command("RSET")->response() == CMD_OK }
+sub _NOOP { shift->command("NOOP")->response() == CMD_OK }
+sub _QUIT { shift->command("QUIT")->response() == CMD_OK }
+sub _DATA { shift->command("DATA")->response() == CMD_MORE }
+sub _BDAT { shift->command("BDAT", @_) }
+sub _TURN { shift->unsupported(@_); }
+sub _ETRN { shift->command("ETRN", @_)->response() == CMD_OK }
+sub _AUTH { shift->command("AUTH", @_)->response() == CMD_OK }
+sub _STARTTLS { shift->command("STARTTLS")->response() == CMD_OK }
+
+
+{
+  package Net::SMTP::_SSL;
+  our @ISA = ( $ssl_class ? ($ssl_class):(), 'Net::SMTP' );
+  sub starttls { die "SMTP connection is already in SSL mode" }
+  sub start_SSL {
+    my ($class,$smtp,%arg) = @_;
+    delete @arg{ grep { !m{^SSL_} } keys %arg };
+    ( $arg{SSL_verifycn_name} ||= $smtp->host )
+        =~s{(?<!:):[\w()]+$}{}; # strip port
+    $arg{SSL_hostname} = $arg{SSL_verifycn_name}
+        if ! defined $arg{SSL_hostname} && $class->can_client_sni;
+    $arg{SSL_verifycn_scheme} ||= 'smtp';
+    my $ok = $class->SUPER::start_SSL($smtp,%arg);
+    $@ = $ssl_class->errstr if !$ok;
+    return $ok;
+  }
+}
+
+
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::SMTP - Simple Mail Transfer Protocol Client
+
+=head1 SYNOPSIS
+
+    use Net::SMTP;
+
+    # Constructors
+    $smtp = Net::SMTP->new('mailhost');
+    $smtp = Net::SMTP->new('mailhost', Timeout => 60);
+
+=head1 DESCRIPTION
+
+This module implements a client interface to the SMTP and ESMTP
+protocol, enabling a perl5 application to talk to SMTP servers. This
+documentation assumes that you are familiar with the concepts of the
+SMTP protocol described in RFC2821.
+With L<IO::Socket::SSL> installed it also provides support for implicit and
+explicit TLS encryption, i.e. SMTPS or SMTP+STARTTLS.
+
+The Net::SMTP class is a subclass of Net::Cmd and (depending on avaibility) of
+IO::Socket::IP, IO::Socket::INET6 or IO::Socket::INET.
+
+=head2 Class Methods
+
+=over 4
+
+=item C<new([$host][, %options])>
+
+This is the constructor for a new Net::SMTP object. C<$host> is the
+name of the remote host to which an SMTP connection is required.
+
+On failure C<undef> will be returned and C<$@> will contain the reason
+for the failure.
+
+C<$host> is optional. If C<$host> is not given then it may instead be
+passed as the C<Host> option described below. If neither is given then
+the C<SMTP_Hosts> specified in C<Net::Config> will be used.
+
+C<%options> are passed in a hash like fashion, using key and value pairs.
+Possible options are:
+
+B<Hello> - SMTP requires that you identify yourself. This option
+specifies a string to pass as your mail domain. If not given localhost.localdomain
+will be used.
+
+B<SendHello> - If false then the EHLO (or HELO) command that is normally sent
+when constructing the object will not be sent. In that case the command will
+have to be sent manually by calling C<hello()> instead.
+
+B<Host> - SMTP host to connect to. It may be a single scalar (hostname[:port]),
+as defined for the C<PeerAddr> option in L<IO::Socket::INET>, or a reference to
+an array with hosts to try in turn. The L</host> method will return the value
+which was used to connect to the host.
+Format - C<PeerHost> from L<IO::Socket::INET> new method.
+
+B<Port> - port to connect to.
+Default - 25 for plain SMTP and 465 for immediate SSL.
+
+B<SSL> - If the connection should be done from start with SSL, contrary to later
+upgrade with C<starttls>.
+You can use SSL arguments as documented in L<IO::Socket::SSL>, but it will
+usually use the right arguments already.
+
+B<LocalAddr> and B<LocalPort> - These parameters are passed directly
+to IO::Socket to allow binding the socket to a specific local address and port.
+
+B<Domain> - This parameter is passed directly to IO::Socket and makes it
+possible to enforce IPv4 connections even if L<IO::Socket::IP> is used as super
+class. Alternatively B<Family> can be used.
+
+B<Timeout> - Maximum time, in seconds, to wait for a response from the
+SMTP server (default: 120)
+
+B<ExactAddresses> - If true then all C<$address> arguments must be as
+defined by C<addr-spec> in RFC2822. If not given, or false, then
+Net::SMTP will attempt to extract the address from the value passed.
+
+B<Debug> - Enable debugging information
+
+Example:
+
+    $smtp = Net::SMTP->new('mailhost',
+                           Hello => 'my.mail.domain',
+                           Timeout => 30,
+                           Debug   => 1,
+                          );
+
+    # the same
+    $smtp = Net::SMTP->new(
+                           Host => 'mailhost',
+                           Hello => 'my.mail.domain',
+                           Timeout => 30,
+                           Debug   => 1,
+                          );
+
+    # the same with direct SSL
+    $smtp = Net::SMTP->new('mailhost',
+                           Hello => 'my.mail.domain',
+                           Timeout => 30,
+                           Debug   => 1,
+                           SSL     => 1,
+                          );
+
+    # Connect to the default server from Net::config
+    $smtp = Net::SMTP->new(
+                           Hello => 'my.mail.domain',
+                           Timeout => 30,
+                          );
+
+=back
+
+=head1 Object Methods
+
+Unless otherwise stated all methods return either a I<true> or I<false>
+value, with I<true> meaning that the operation was a success. When a method
+states that it returns a value, failure will be returned as I<undef> or an
+empty list.
+
+C<Net::SMTP> inherits from C<Net::Cmd> so methods defined in C<Net::Cmd> may
+be used to send commands to the remote SMTP server in addition to the methods
+documented here.
+
+=over 4
+
+=item C<banner()>
+
+Returns the banner message which the server replied with when the
+initial connection was made.
+
+=item C<domain()>
+
+Returns the domain that the remote SMTP server identified itself as during
+connection.
+
+=item C<hello($domain)>
+
+Tell the remote server the mail domain which you are in using the EHLO
+command (or HELO if EHLO fails).  Since this method is invoked
+automatically when the Net::SMTP object is constructed the user should
+normally not have to call it manually.
+
+=item C<host()>
+
+Returns the value used by the constructor, and passed to IO::Socket::INET,
+to connect to the host.
+
+=item C<etrn($domain)>
+
+Request a queue run for the C<$domain> given.
+
+=item C<starttls(%sslargs)>
+
+Upgrade existing plain connection to SSL.
+You can use SSL arguments as documented in L<IO::Socket::SSL>, but it will
+usually use the right arguments already.
+
+=item C<auth($username, $password)>
+
+=item C<auth($sasl)>
+
+Attempt SASL authentication. Requires Authen::SASL module. The first form
+constructs a new Authen::SASL object using the given username and password;
+the second form uses the given Authen::SASL object.
+
+=item C<mail($address[, %options])>
+
+=item C<send($address)>
+
+=item C<send_or_mail($address)>
+
+=item C<send_and_mail($address)>
+
+Send the appropriate command to the server MAIL, SEND, SOML or SAML. C<$address>
+is the address of the sender. This initiates the sending of a message. The
+method C<recipient> should be called for each address that the message is to
+be sent to.
+
+The C<mail> method can take some additional ESMTP C<%options> which is passed
+in hash like fashion, using key and value pairs.  Possible options are:
+
+ Size        => <bytes>
+ Return      => "FULL" | "HDRS"
+ Bits        => "7" | "8" | "binary"
+ Transaction => <ADDRESS>
+ Envelope    => <ENVID>     # xtext-encodes its argument
+ ENVID       => <ENVID>     # similar to Envelope, but expects argument encoded
+ XVERP       => 1
+ AUTH        => <submitter> # encoded address according to RFC 2554
+
+The C<Return> and C<Envelope> parameters are used for DSN (Delivery
+Status Notification).
+
+The submitter address in C<AUTH> option is expected to be in a format as
+required by RFC 2554, in an RFC2821-quoted form and xtext-encoded, or <> .
+
+=item C<reset()>
+
+Reset the status of the server. This may be called after a message has been 
+initiated, but before any data has been sent, to cancel the sending of the
+message.
+
+=item C<recipient($address[, $address[, ...]][, %options])>
+
+Notify the server that the current message should be sent to all of the
+addresses given. Each address is sent as a separate command to the server.
+Should the sending of any address result in a failure then the process is
+aborted and a I<false> value is returned. It is up to the user to call
+C<reset> if they so desire.
+
+The C<recipient> method can also pass additional case-sensitive C<%options> as an
+anonymous hash using key and value pairs.  Possible options are:
+
+  Notify  => ['NEVER'] or ['SUCCESS','FAILURE','DELAY']  (see below)
+  ORcpt   => <ORCPT>
+  SkipBad => 1        (to ignore bad addresses)
+
+If C<SkipBad> is true the C<recipient> will not return an error when a bad
+address is encountered and it will return an array of addresses that did
+succeed.
+
+  $smtp->recipient($recipient1,$recipient2);  # Good
+  $smtp->recipient($recipient1,$recipient2, { SkipBad => 1 });  # Good
+  $smtp->recipient($recipient1,$recipient2, { Notify => ['FAILURE','DELAY'], SkipBad => 1 });  # Good
+  @goodrecips=$smtp->recipient(@recipients, { Notify => ['FAILURE'], SkipBad => 1 });  # Good
+  $smtp->recipient("$recipient,$recipient2"); # BAD
+
+Notify is used to request Delivery Status Notifications (DSNs), but your
+SMTP/ESMTP service may not respect this request depending upon its version and
+your site's SMTP configuration.
+
+Leaving out the Notify option usually defaults an SMTP service to its default
+behavior equivalent to ['FAILURE'] notifications only, but again this may be
+dependent upon your site's SMTP configuration.
+
+The NEVER keyword must appear by itself if used within the Notify option and "requests
+that a DSN not be returned to the sender under any conditions."
+
+  {Notify => ['NEVER']}
+
+  $smtp->recipient(@recipients, { Notify => ['NEVER'], SkipBad => 1 });  # Good
+
+You may use any combination of these three values 'SUCCESS','FAILURE','DELAY' in
+the anonymous array reference as defined by RFC3461 (see
+L<https://www.ietf.org/rfc/rfc3461.txt> for more information.  Note: quotations
+in this topic from same.).
+
+A Notify parameter of 'SUCCESS' or 'FAILURE' "requests that a DSN be issued on
+successful delivery or delivery failure, respectively."
+
+A Notify parameter of 'DELAY' "indicates the sender's willingness to receive
+delayed DSNs.  Delayed DSNs may be issued if delivery of a message has been
+delayed for an unusual amount of time (as determined by the Message Transfer
+Agent (MTA) at which the message is delayed), but the final delivery status
+(whether successful or failure) cannot be determined.  The absence of the DELAY
+keyword in a NOTIFY parameter requests that a "delayed" DSN NOT be issued under
+any conditions."
+
+  {Notify => ['SUCCESS','FAILURE','DELAY']}
+
+  $smtp->recipient(@recipients, { Notify => ['FAILURE','DELAY'], SkipBad => 1 });  # Good
+
+ORcpt is also part of the SMTP DSN extension according to RFC3461.
+It is used to pass along the original recipient that the mail was first
+sent to.  The machine that generates a DSN will use this address to inform
+the sender, because he can't know if recipients get rewritten by mail servers.
+It is expected to be in a format as required by RFC3461, xtext-encoded.
+
+=item C<to($address[, $address[, ...]])>
+
+=item C<cc($address[, $address[, ...]])>
+
+=item C<bcc($address[, $address[, ...]])>
+
+Synonyms for C<recipient>.
+
+=item C<data([$data])>
+
+Initiate the sending of the data from the current message. 
+
+C<$data> may be a reference to a list or a list and must be encoded by the
+caller to octets of whatever encoding is required, e.g. by using the Encode
+module's C<encode()> function.
+
+If specified the contents of C<$data> and a termination string C<".\r\n"> is
+sent to the server. The result will be true if the data was accepted.
+
+If C<$data> is not specified then the result will indicate that the server
+wishes the data to be sent. The data must then be sent using the C<datasend>
+and C<dataend> methods described in L<Net::Cmd>.
+
+=item C<bdat($data)>
+
+=item C<bdatlast($data)>
+
+Use the alternate C<$data> command "BDAT" of the data chunking service extension
+defined in RFC1830 for efficiently sending large MIME messages.
+
+=item C<expand($address)>
+
+Request the server to expand the given address Returns an array
+which contains the text read from the server.
+
+=item C<verify($address)>
+
+Verify that C<$address> is a legitimate mailing address.
+
+Most sites usually disable this feature in their SMTP service configuration.
+Use "Debug => 1" option under new() to see if disabled.
+
+=item C<help([$subject])>
+
+Request help text from the server. Returns the text or undef upon failure
+
+=item C<quit()>
+
+Send the QUIT command to the remote SMTP server and close the socket connection.
+
+=item C<can_inet6()>
+
+Returns whether we can use IPv6.
+
+=item C<can_ssl()>
+
+Returns whether we can use SSL.
+
+=back
+
+=head2 Addresses
+
+Net::SMTP attempts to DWIM with addresses that are passed. For
+example an application might extract The From: line from an email
+and pass that to mail(). While this may work, it is not recommended.
+The application should really use a module like L<Mail::Address>
+to extract the mail address and pass that.
+
+If C<ExactAddresses> is passed to the constructor, then addresses
+should be a valid rfc2821-quoted address, although Net::SMTP will
+accept the address surrounded by angle brackets.
+
+ funny user@domain      WRONG
+ "funny user"@domain    RIGHT, recommended
+ <"funny user"@domain>  OK
+
+=head1 EXAMPLES
+
+This example prints the mail domain name of the SMTP server known as mailhost:
+
+    #!/usr/local/bin/perl -w
+
+    use Net::SMTP;
+
+    $smtp = Net::SMTP->new('mailhost');
+    print $smtp->domain,"\n";
+    $smtp->quit;
+
+This example sends a small message to the postmaster at the SMTP server
+known as mailhost:
+
+    #!/usr/local/bin/perl -w
+
+    use Net::SMTP;
+
+    my $smtp = Net::SMTP->new('mailhost');
+
+    $smtp->mail($ENV{USER});
+    if ($smtp->to('postmaster')) {
+     $smtp->data();
+     $smtp->datasend("To: postmaster\n");
+     $smtp->datasend("\n");
+     $smtp->datasend("A simple test message\n");
+     $smtp->dataend();
+    } else {
+     print "Error: ", $smtp->message();
+    }
+
+    $smtp->quit;
+
+=head1 EXPORTS
+
+I<None>.
+
+=head1 KNOWN BUGS
+
+See L<https://rt.cpan.org/Dist/Display.html?Status=Active&Queue=libnet>.
+
+=head1 SEE ALSO
+
+L<Net::Cmd>,
+L<IO::Socket::SSL>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+
+Copyright (C) 2013-2016, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/Time.pm

@@ -0,0 +1,203 @@
+# Net::Time.pm
+#
+# Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+# Copyright (C) 2014, 2020 Steve Hay.  All rights reserved.
+# This module is free software; you can redistribute it and/or modify it under
+# the same terms as Perl itself, i.e. under the terms of either the GNU General
+# Public License or the Artistic License, as specified in the F<LICENCE> file.
+
+package Net::Time;
+
+use 5.008001;
+
+use strict;
+use warnings;
+
+use Carp;
+use Exporter;
+use IO::Select;
+use IO::Socket;
+use Net::Config;
+
+our @ISA       = qw(Exporter);
+our @EXPORT_OK = qw(inet_time inet_daytime);
+
+our $VERSION = "3.15";
+
+our $TIMEOUT = 120;
+
+sub _socket {
+  my ($pname, $pnum, $host, $proto, $timeout) = @_;
+
+  $proto ||= 'udp';
+
+  my $port = (getservbyname($pname, $proto))[2] || $pnum;
+
+  my $hosts = defined $host ? [$host] : $NetConfig{$pname . '_hosts'};
+
+  my $me;
+
+  foreach my $addr (@$hosts) {
+    $me = IO::Socket::INET->new(
+      PeerAddr => $addr,
+      PeerPort => $port,
+      Proto    => $proto
+      )
+      and last;
+  }
+
+  return unless $me;
+
+  $me->send("\n")
+    if $proto eq 'udp';
+
+  $timeout = $TIMEOUT
+    unless defined $timeout;
+
+  IO::Select->new($me)->can_read($timeout)
+    ? $me
+    : undef;
+}
+
+
+sub inet_time {
+  my $s      = _socket('time', 37, @_) || return;
+  my $buf    = '';
+  my $offset = 0 | 0;
+
+  return
+    unless defined $s->recv($buf, length(pack("N", 0)));
+
+  # unpack, we | 0 to ensure we have an unsigned
+  my $time = (unpack("N", $buf))[0] | 0;
+
+  # the time protocol return time in seconds since 1900, convert
+  # it to a the required format
+
+  if ($^O eq "MacOS") {
+
+    # MacOS return seconds since 1904, 1900 was not a leap year.
+    $offset = (4 * 31536000) | 0;
+  }
+  else {
+
+    # otherwise return seconds since 1972, there were 17 leap years between
+    # 1900 and 1972
+    $offset = (70 * 31536000 + 17 * 86400) | 0;
+  }
+
+  $time - $offset;
+}
+
+
+sub inet_daytime {
+  my $s   = _socket('daytime', 13, @_) || return;
+  my $buf = '';
+
+  defined($s->recv($buf, 1024))
+    ? $buf
+    : undef;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::Time - time and daytime network client interface
+
+=head1 SYNOPSIS
+
+    use Net::Time qw(inet_time inet_daytime);
+
+    print inet_time();          # use default host from Net::Config
+    print inet_time('localhost');
+    print inet_time('localhost', 'tcp');
+
+    print inet_daytime();       # use default host from Net::Config
+    print inet_daytime('localhost');
+    print inet_daytime('localhost', 'tcp');
+
+=head1 DESCRIPTION
+
+C<Net::Time> provides subroutines that obtain the time on a remote machine.
+
+=head2 Functions
+
+=over 4
+
+=item C<inet_time([$host[, $protocol[, $timeout]]])>
+
+Obtain the time on C<$host>, or some default host if C<$host> is not given
+or not defined, using the protocol as defined in RFC868. The optional
+argument C<$protocol> should define the protocol to use, either C<tcp> or
+C<udp>. The result will be a time value in the same units as returned
+by time() or I<undef> upon failure.
+
+=item C<inet_daytime([$host[, $protocol[, $timeout]]])>
+
+Obtain the time on C<$host>, or some default host if C<$host> is not given
+or not defined, using the protocol as defined in RFC867. The optional
+argument C<$protocol> should define the protocol to use, either C<tcp> or
+C<udp>. The result will be an ASCII string or I<undef> upon failure.
+
+=back
+
+=head1 EXPORTS
+
+The following symbols are, or can be, exported by this module:
+
+=over 4
+
+=item Default Exports
+
+I<None>.
+
+=item Optional Exports
+
+C<inet_time>,
+C<inet_daytime>.
+
+=item Export Tags
+
+I<None>.
+
+=back
+
+=head1 KNOWN BUGS
+
+I<None>.
+
+=head1 AUTHOR
+
+Graham Barr E<lt>L<gbarr@pobox.com|mailto:gbarr@pobox.com>E<gt>.
+
+Steve Hay E<lt>L<shay@cpan.org|mailto:shay@cpan.org>E<gt> is now maintaining
+libnet as of version 1.22_02.
+
+=head1 COPYRIGHT
+
+Copyright (C) 1995-2004 Graham Barr.  All rights reserved.
+
+Copyright (C) 2014, 2020 Steve Hay.  All rights reserved.
+
+=head1 LICENCE
+
+This module is free software; you can redistribute it and/or modify it under the
+same terms as Perl itself, i.e. under the terms of either the GNU General Public
+License or the Artistic License, as specified in the F<LICENCE> file.
+
+=head1 VERSION
+
+Version 3.15
+
+=head1 DATE
+
+20 March 2023
+
+=head1 HISTORY
+
+See the F<Changes> file.
+
+=cut

git/usr/share/perl5/core_perl/Net/hostent.pm

@@ -0,0 +1,148 @@
+package Net::hostent 1.04;
+use v5.38;
+
+our (
+      $h_name, @h_aliases,
+      $h_addrtype, $h_length,
+      @h_addr_list, $h_addr
+);
+
+use Exporter 'import';
+our @EXPORT      = qw(gethostbyname gethostbyaddr gethost);
+our @EXPORT_OK   = qw(
+			$h_name	    	@h_aliases
+			$h_addrtype 	$h_length
+			@h_addr_list 	$h_addr
+		   );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+use Class::Struct qw(struct);
+struct 'Net::hostent' => [
+   name		=> '$',
+   aliases	=> '@',
+   addrtype	=> '$',
+   'length'	=> '$',
+   addr_list	=> '@',
+];
+
+sub addr { shift->addr_list->[0] }
+
+sub populate {
+    return unless @_;
+    my $hob = new();
+    $h_name 	 =    $hob->[0]     	     = $_[0];
+    @h_aliases	 = @{ $hob->[1] } = split ' ', $_[1];
+    $h_addrtype  =    $hob->[2] 	     = $_[2];
+    $h_length	 =    $hob->[3] 	     = $_[3];
+    $h_addr 	 =                             $_[4];
+    @h_addr_list = @{ $hob->[4] } =          @_[ (4 .. $#_) ];
+    return $hob;
+} 
+
+sub gethostbyname :prototype($) { populate(CORE::gethostbyname(shift)) }
+
+sub gethostbyaddr :prototype($;$) {
+    my ($addr, $addrtype);
+    $addr = shift;
+    require Socket unless @_;
+    $addrtype = @_ ? shift : Socket::AF_INET();
+    populate(CORE::gethostbyaddr($addr, $addrtype)) 
+} 
+
+sub gethost :prototype($) {
+    my $addr = shift;
+    if ($addr =~ /^\d+(?:\.\d+(?:\.\d+(?:\.\d+)?)?)?$/) {
+       require Socket;
+       &gethostbyaddr(Socket::inet_aton($addr));
+    } else {
+       &gethostbyname($addr);
+    }
+}
+
+__END__
+
+=head1 NAME
+
+Net::hostent - by-name interface to Perl's built-in gethost*() functions
+
+=head1 SYNOPSIS
+
+ use Net::hostent;
+
+=head1 DESCRIPTION
+
+This module's default exports override the core gethostbyname() and
+gethostbyaddr() functions, replacing them with versions that return
+"Net::hostent" objects.  This object has methods that return the similarly
+named structure field name from the C's hostent structure from F<netdb.h>;
+namely name, aliases, addrtype, length, and addr_list.  The aliases and
+addr_list methods return array reference, the rest scalars.  The addr
+method is equivalent to the zeroth element in the addr_list array
+reference.
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this still
+overrides your core functions.)  Access these fields as variables named
+with a preceding C<h_>.  Thus, C<$host_obj-E<gt>name()> corresponds to
+$h_name if you import the fields.  Array references are available as
+regular array variables, so for example C<@{ $host_obj-E<gt>aliases()
+}> would be simply @h_aliases.
+
+The gethost() function is a simple front-end that forwards a numeric
+argument to gethostbyaddr() by way of Socket::inet_aton, and the rest
+to gethostbyname().
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 EXAMPLES
+
+ use Net::hostent;
+ use Socket;
+
+ @ARGV = ('netscape.com') unless @ARGV;
+
+ for $host ( @ARGV ) {
+
+    unless ($h = gethost($host)) {
+	warn "$0: no such host: $host\n";
+	next;
+    }
+
+    printf "\n%s is %s%s\n", 
+	    $host, 
+	    lc($h->name) eq lc($host) ? "" : "*really* ",
+	    $h->name;
+
+    print "\taliases are ", join(", ", @{$h->aliases}), "\n"
+		if @{$h->aliases};     
+
+    if ( @{$h->addr_list} > 1 ) { 
+	my $i;
+	for $addr ( @{$h->addr_list} ) {
+	    printf "\taddr #%d is [%s]\n", $i++, inet_ntoa($addr);
+	} 
+    } else {
+	printf "\taddress is [%s]\n", inet_ntoa($h->addr);
+    } 
+
+    if ($h = gethostbyaddr($h->addr)) {
+	if (lc($h->name) ne lc($host)) {
+	    printf "\tThat addr reverses to host %s!\n", $h->name;
+	    $host = $h->name;
+	    redo;
+	} 
+    }
+ }
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Net/netent.pm

@@ -0,0 +1,164 @@
+package Net::netent 1.02;
+use v5.38;
+
+our (
+    $n_name, @n_aliases,
+    $n_addrtype, $n_net
+);
+ 
+use Exporter 'import';
+our @EXPORT      = qw(getnetbyname getnetbyaddr getnet);
+our @EXPORT_OK   = qw(
+			$n_name	    	@n_aliases
+			$n_addrtype 	$n_net
+		   );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+use Class::Struct qw(struct);
+struct 'Net::netent' => [
+   name		=> '$',
+   aliases	=> '@',
+   addrtype	=> '$',
+   net		=> '$',
+];
+
+sub populate {
+    return unless @_;
+    my $nob = new();
+    $n_name 	 =    $nob->[0]     	     = $_[0];
+    @n_aliases	 = @{ $nob->[1] } = split ' ', $_[1];
+    $n_addrtype  =    $nob->[2] 	     = $_[2];
+    $n_net	 =    $nob->[3] 	     = $_[3];
+    return $nob;
+} 
+
+sub getnetbyname :prototype($) { populate(CORE::getnetbyname(shift)) }
+
+sub getnetbyaddr :prototype($;$) {
+    my ($net, $addrtype);
+    $net = shift;
+    require Socket if @_;
+    $addrtype = @_ ? shift : Socket::AF_INET();
+    populate(CORE::getnetbyaddr($net, $addrtype)) 
+} 
+
+sub getnet :prototype($) {
+    if ($_[0] =~ /^\d+(?:\.\d+(?:\.\d+(?:\.\d+)?)?)?$/) {
+	require Socket;
+	&getnetbyaddr(Socket::inet_aton(shift));
+    } else {
+	&getnetbyname;
+    } 
+} 
+
+__END__
+
+=head1 NAME
+
+Net::netent - by-name interface to Perl's built-in getnet*() functions
+
+=head1 SYNOPSIS
+
+ use Net::netent qw(:FIELDS);
+ getnetbyname("loopback") 		or die "bad net";
+ printf "%s is %08X\n", $n_name, $n_net;
+
+ use Net::netent;
+
+ $n = getnetbyname("loopback") 		or die "bad net";
+ { # there's gotta be a better way, eh?
+     @bytes = unpack("C4", pack("N", $n->net));
+     shift @bytes while @bytes && $bytes[0] == 0;
+ }
+ printf "%s is %08X [%d.%d.%d.%d]\n", $n->name, $n->net, @bytes;
+
+=head1 DESCRIPTION
+
+This module's default exports override the core getnetbyname() and
+getnetbyaddr() functions, replacing them with versions that return
+"Net::netent" objects.  This object has methods that return the similarly
+named structure field name from the C's netent structure from F<netdb.h>;
+namely name, aliases, addrtype, and net.  The aliases 
+method returns an array reference, the rest scalars.  
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this still
+overrides your core functions.)  Access these fields as variables named
+with a preceding C<n_>.  Thus, C<$net_obj-E<gt>name()> corresponds to
+$n_name if you import the fields.  Array references are available as
+regular array variables, so for example C<@{ $net_obj-E<gt>aliases()
+}> would be simply @n_aliases.
+
+The getnet() function is a simple front-end that forwards a numeric
+argument to getnetbyaddr(), and the rest
+to getnetbyname().
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 EXAMPLES
+
+The getnet() functions do this in the Perl core:
+
+    sv_setiv(sv, (I32)nent->n_net);
+
+The gethost() functions do this in the Perl core:
+
+    sv_setpvn(sv, hent->h_addr, len);
+
+That means that the address comes back in binary for the
+host functions, and as a regular perl integer for the net ones.
+This seems a bug, but here's how to deal with it:
+
+ use strict;
+ use Socket;
+ use Net::netent;
+
+ @ARGV = ('loopback') unless @ARGV;
+
+ my($n, $net);
+
+ for $net ( @ARGV ) {
+
+     unless ($n = getnetbyname($net)) {
+ 	warn "$0: no such net: $net\n";
+ 	next;
+     }
+
+     printf "\n%s is %s%s\n", 
+ 	    $net, 
+ 	    lc($n->name) eq lc($net) ? "" : "*really* ",
+ 	    $n->name;
+
+     print "\taliases are ", join(", ", @{$n->aliases}), "\n"
+ 		if @{$n->aliases};     
+
+     # this is stupid; first, why is this not in binary?
+     # second, why am i going through these convolutions
+     # to make it looks right
+     {
+ 	my @a = unpack("C4", pack("N", $n->net));
+ 	shift @a while @a && $a[0] == 0;
+ 	printf "\taddr is %s [%d.%d.%d.%d]\n", $n->net, @a;
+     }
+
+     if ($n = getnetbyaddr($n->net)) {
+ 	if (lc($n->name) ne lc($net)) {
+ 	    printf "\tThat addr reverses to net %s!\n", $n->name;
+ 	    $net = $n->name;
+ 	    redo;
+ 	} 
+     }
+ }
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Net/protoent.pm

@@ -0,0 +1,87 @@
+package Net::protoent 1.03;
+use v5.38;
+
+our ( $p_name, @p_aliases, $p_proto );
+
+use Exporter 'import';
+our @EXPORT      = qw(getprotobyname getprotobynumber getprotoent getproto);
+our @EXPORT_OK   = qw( $p_name @p_aliases $p_proto );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+use Class::Struct qw(struct);
+struct 'Net::protoent' => [
+   name		=> '$',
+   aliases	=> '@',
+   proto	=> '$',
+];
+
+sub populate {
+    return unless @_;
+    my $pob = new();
+    $p_name 	 =    $pob->[0]     	     = $_[0];
+    @p_aliases	 = @{ $pob->[1] } = split ' ', $_[1];
+    $p_proto	 =    $pob->[2] 	     = $_[2];
+    return $pob;
+} 
+
+sub getprotoent      :prototype( ) { populate(CORE::getprotoent()) }
+sub getprotobyname   :prototype($) { populate(CORE::getprotobyname(shift)) }
+sub getprotobynumber :prototype($) { populate(CORE::getprotobynumber(shift)) }
+
+sub getproto :prototype($;$) {
+    no strict 'refs';
+    return &{'getprotoby' . ($_[0]=~/^\d+$/ ? 'number' : 'name')}(@_);
+}
+
+__END__
+
+=head1 NAME
+
+Net::protoent - by-name interface to Perl's built-in getproto*() functions
+
+=head1 SYNOPSIS
+
+ use Net::protoent;
+ my $p = getprotobyname(shift || 'tcp') || die "no proto";
+ printf "proto for %s is %d, aliases are %s\n",
+    $p->name, $p->proto, "@{$p->aliases}";
+
+ use Net::protoent qw(:FIELDS);
+ getprotobyname(shift || 'tcp') || die "no proto";
+ print "proto for $p_name is $p_proto, aliases are @p_aliases\n";
+
+=head1 DESCRIPTION
+
+This module's default exports override the core getprotoent(),
+getprotobyname(), and getnetbyport() functions, replacing them with
+versions that return "Net::protoent" objects.  They take default
+second arguments of "tcp".  This object has methods that return the
+similarly named structure field name from the C's protoent structure
+from F<netdb.h>; namely name, aliases, and proto.  The aliases method
+returns an array reference, the rest scalars.
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this still
+overrides your core functions.)  Access these fields as variables named
+with a preceding C<p_>.  Thus, C<$proto_obj-E<gt>name()> corresponds to
+$p_name if you import the fields.  Array references are available as
+regular array variables, so for example C<@{ $proto_obj-E<gt>aliases()
+}> would be simply @p_aliases.
+
+The getproto() function is a simple front-end that forwards a numeric
+argument to getprotobyport(), and the rest to getprotobyname().
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Net/servent.pm

@@ -0,0 +1,104 @@
+package Net::servent 1.04;
+use v5.38;
+
+our ( $s_name, @s_aliases, $s_port, $s_proto );
+
+use Exporter 'import';
+our @EXPORT      = qw(getservbyname getservbyport getservent getserv);
+our @EXPORT_OK   = qw( $s_name @s_aliases $s_port $s_proto );
+our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] );
+
+use Class::Struct qw(struct);
+struct 'Net::servent' => [
+   name		=> '$',
+   aliases	=> '@',
+   port		=> '$',
+   proto	=> '$',
+];
+
+sub populate {
+    return unless @_;
+    my $sob = new();
+    $s_name 	 =    $sob->[0]     	     = $_[0];
+    @s_aliases	 = @{ $sob->[1] } = split ' ', $_[1];
+    $s_port	 =    $sob->[2] 	     = $_[2];
+    $s_proto	 =    $sob->[3] 	     = $_[3];
+    return $sob;
+}
+
+sub getservent    :prototype(   ) { populate(CORE::getservent()) }
+sub getservbyname :prototype($;$) { populate(CORE::getservbyname(shift,shift||'tcp')) }
+sub getservbyport :prototype($;$) { populate(CORE::getservbyport(shift,shift||'tcp')) }
+
+sub getserv :prototype($;$) {
+    no strict 'refs';
+    return &{'getservby' . ($_[0]=~/^\d+$/ ? 'port' : 'name')}(@_);
+}
+
+__END__
+
+=head1 NAME
+
+Net::servent - by-name interface to Perl's built-in getserv*() functions
+
+=head1 SYNOPSIS
+
+ use Net::servent;
+ my $s = getservbyname(shift || 'ftp') || die "no service";
+ printf "port for %s is %s, aliases are %s\n",
+    $s->name, $s->port, "@{$s->aliases}";
+
+ use Net::servent qw(:FIELDS);
+ getservbyname(shift || 'ftp') || die "no service";
+ print "port for $s_name is $s_port, aliases are @s_aliases\n";
+
+=head1 DESCRIPTION
+
+This module's default exports override the core getservent(),
+getservbyname(), and
+getnetbyport() functions, replacing them with versions that return
+"Net::servent" objects.  They take default second arguments of "tcp".  This object has methods that return the similarly
+named structure field name from the C's servent structure from F<netdb.h>;
+namely name, aliases, port, and proto.  The aliases
+method returns an array reference, the rest scalars.
+
+You may also import all the structure fields directly into your namespace
+as regular variables using the :FIELDS import tag.  (Note that this still
+overrides your core functions.)  Access these fields as variables named
+with a preceding C<s_>.  Thus, C<$serv_obj-E<gt>name()> corresponds to
+$s_name if you import the fields.  Array references are available as
+regular array variables, so for example C<@{ $serv_obj-E<gt>aliases()}>
+would be simply @s_aliases.
+
+The getserv() function is a simple front-end that forwards a numeric
+argument to getservbyport(), and the rest to getservbyname().
+
+To access this functionality without the core overrides,
+pass the C<use> an empty import list, and then access
+function functions with their full qualified names.
+On the other hand, the built-ins are still available
+via the C<CORE::> pseudo-package.
+
+=head1 EXAMPLES
+
+ use Net::servent qw(:FIELDS);
+
+ while (@ARGV) {
+     my ($service, $proto) = ((split m!/!, shift), 'tcp');
+     my $valet = getserv($service, $proto);
+     unless ($valet) {
+         warn "$0: No service: $service/$proto\n"
+         next;
+     }
+     printf "service $service/$proto is port %d\n", $valet->port;
+     print "alias are @s_aliases\n" if @s_aliases;
+ }
+
+=head1 NOTE
+
+While this class is currently implemented using the Class::Struct
+module to build a struct-like class, you shouldn't rely upon this.
+
+=head1 AUTHOR
+
+Tom Christiansen

git/usr/share/perl5/core_perl/Params/Check.pm

@@ -0,0 +1,695 @@
+package Params::Check;
+
+use strict;
+
+use Carp                        qw[carp croak];
+use Locale::Maketext::Simple    Style => 'gettext';
+
+BEGIN {
+    use Exporter    ();
+    use vars        qw[ @ISA $VERSION @EXPORT_OK $VERBOSE $ALLOW_UNKNOWN
+                        $STRICT_TYPE $STRIP_LEADING_DASHES $NO_DUPLICATES
+                        $PRESERVE_CASE $ONLY_ALLOW_DEFINED $WARNINGS_FATAL
+                        $SANITY_CHECK_TEMPLATE $CALLER_DEPTH $_ERROR_STRING
+                    ];
+
+    @ISA        =   qw[ Exporter ];
+    @EXPORT_OK  =   qw[check allow last_error];
+
+    $VERSION                = '0.38';
+    $VERBOSE                = $^W ? 1 : 0;
+    $NO_DUPLICATES          = 0;
+    $STRIP_LEADING_DASHES   = 0;
+    $STRICT_TYPE            = 0;
+    $ALLOW_UNKNOWN          = 0;
+    $PRESERVE_CASE          = 0;
+    $ONLY_ALLOW_DEFINED     = 0;
+    $SANITY_CHECK_TEMPLATE  = 1;
+    $WARNINGS_FATAL         = 0;
+    $CALLER_DEPTH           = 0;
+}
+
+my %known_keys = map { $_ => 1 }
+                    qw| required allow default strict_type no_override
+                        store defined |;
+
+=pod
+
+=head1 NAME
+
+Params::Check - A generic input parsing/checking mechanism.
+
+=head1 SYNOPSIS
+
+    use Params::Check qw[check allow last_error];
+
+    sub fill_personal_info {
+        my %hash = @_;
+        my $x;
+
+        my $tmpl = {
+            firstname   => { required   => 1, defined => 1 },
+            lastname    => { required   => 1, store => \$x },
+            gender      => { required   => 1,
+                             allow      => [qr/M/i, qr/F/i],
+                           },
+            married     => { allow      => [0,1] },
+            age         => { default    => 21,
+                             allow      => qr/^\d+$/,
+                           },
+
+            phone       => { allow => [ sub { return 1 if /$valid_re/ },
+                                        '1-800-PERL' ]
+                           },
+            id_list     => { default        => [],
+                             strict_type    => 1
+                           },
+            employer    => { default => 'NSA', no_override => 1 },
+        };
+
+        ### check() returns a hashref of parsed args on success ###
+        my $parsed_args = check( $tmpl, \%hash, $VERBOSE )
+                            or die qw[Could not parse arguments!];
+
+        ... other code here ...
+    }
+
+    my $ok = allow( $colour, [qw|blue green yellow|] );
+
+    my $error = Params::Check::last_error();
+
+
+=head1 DESCRIPTION
+
+Params::Check is a generic input parsing/checking mechanism.
+
+It allows you to validate input via a template. The only requirement
+is that the arguments must be named.
+
+Params::Check can do the following things for you:
+
+=over 4
+
+=item *
+
+Convert all keys to lowercase
+
+=item *
+
+Check if all required arguments have been provided
+
+=item *
+
+Set arguments that have not been provided to the default
+
+=item *
+
+Weed out arguments that are not supported and warn about them to the
+user
+
+=item *
+
+Validate the arguments given by the user based on strings, regexes,
+lists or even subroutines
+
+=item *
+
+Enforce type integrity if required
+
+=back
+
+Most of Params::Check's power comes from its template, which we'll
+discuss below:
+
+=head1 Template
+
+As you can see in the synopsis, based on your template, the arguments
+provided will be validated.
+
+The template can take a different set of rules per key that is used.
+
+The following rules are available:
+
+=over 4
+
+=item default
+
+This is the default value if none was provided by the user.
+This is also the type C<strict_type> will look at when checking type
+integrity (see below).
+
+=item required
+
+A boolean flag that indicates if this argument was a required
+argument. If marked as required and not provided, check() will fail.
+
+=item strict_type
+
+This does a C<ref()> check on the argument provided. The C<ref> of the
+argument must be the same as the C<ref> of the default value for this
+check to pass.
+
+This is very useful if you insist on taking an array reference as
+argument for example.
+
+=item defined
+
+If this template key is true, enforces that if this key is provided by
+user input, its value is C<defined>. This just means that the user is
+not allowed to pass C<undef> as a value for this key and is equivalent
+to:
+    allow => sub { defined $_[0] && OTHER TESTS }
+
+=item no_override
+
+This allows you to specify C<constants> in your template. ie, they
+keys that are not allowed to be altered by the user. It pretty much
+allows you to keep all your C<configurable> data in one place; the
+C<Params::Check> template.
+
+=item store
+
+This allows you to pass a reference to a scalar, in which the data
+will be stored:
+
+    my $x;
+    my $args = check(foo => { default => 1, store => \$x }, $input);
+
+This is basically shorthand for saying:
+
+    my $args = check( { foo => { default => 1 }, $input );
+    my $x    = $args->{foo};
+
+You can alter the global variable $Params::Check::NO_DUPLICATES to
+control whether the C<store>'d key will still be present in your
+result set. See the L<Global Variables> section below.
+
+=item allow
+
+A set of criteria used to validate a particular piece of data if it
+has to adhere to particular rules.
+
+See the C<allow()> function for details.
+
+=back
+
+=head1 Functions
+
+=head2 check( \%tmpl, \%args, [$verbose] );
+
+This function is not exported by default, so you'll have to ask for it
+via:
+
+    use Params::Check qw[check];
+
+or use its fully qualified name instead.
+
+C<check> takes a list of arguments, as follows:
+
+=over 4
+
+=item Template
+
+This is a hash reference which contains a template as explained in the
+C<SYNOPSIS> and C<Template> section.
+
+=item Arguments
+
+This is a reference to a hash of named arguments which need checking.
+
+=item Verbose
+
+A boolean to indicate whether C<check> should be verbose and warn
+about what went wrong in a check or not.
+
+You can enable this program wide by setting the package variable
+C<$Params::Check::VERBOSE> to a true value. For details, see the
+section on C<Global Variables> below.
+
+=back
+
+C<check> will return when it fails, or a hashref with lowercase
+keys of parsed arguments when it succeeds.
+
+So a typical call to check would look like this:
+
+    my $parsed = check( \%template, \%arguments, $VERBOSE )
+                    or warn q[Arguments could not be parsed!];
+
+A lot of the behaviour of C<check()> can be altered by setting
+package variables. See the section on C<Global Variables> for details
+on this.
+
+=cut
+
+sub check {
+    my ($utmpl, $href, $verbose) = @_;
+
+    ### clear the current error string ###
+    _clear_error();
+
+    ### did we get the arguments we need? ###
+    if ( !$utmpl or !$href ) {
+      _store_error(loc('check() expects two arguments'));
+      return unless $WARNINGS_FATAL;
+      croak(__PACKAGE__->last_error);
+    }
+
+    ### sensible defaults ###
+    $verbose ||= $VERBOSE || 0;
+
+    ### XXX what type of template is it? ###
+    ### { key => { } } ?
+    #if (ref $args eq 'HASH') {
+    #    1;
+    #}
+
+    ### clean up the template ###
+    my $args;
+
+    ### don't even bother to loop, if there's nothing to clean up ###
+    if( $PRESERVE_CASE and !$STRIP_LEADING_DASHES ) {
+        $args = $href;
+    } else {
+        ### keys are not aliased ###
+        for my $key (keys %$href) {
+            my $org = $key;
+            $key = lc $key unless $PRESERVE_CASE;
+            $key =~ s/^-// if $STRIP_LEADING_DASHES;
+            $args->{$key} = $href->{$org};
+        }
+    }
+
+    my %defs;
+
+    ### which template entries have a 'store' member
+    my @want_store;
+
+    ### sanity check + defaults + required keys set? ###
+    my $fail;
+    for my $key (keys %$utmpl) {
+        my $tmpl = $utmpl->{$key};
+
+        ### check if required keys are provided
+        ### keys are now lower cased, unless preserve case was enabled
+        ### at which point, the utmpl keys must match, but that's the users
+        ### problem.
+        if( $tmpl->{'required'} and not exists $args->{$key} ) {
+            _store_error(
+                loc(q|Required option '%1' is not provided for %2 by %3|,
+                    $key, _who_was_it(), _who_was_it(1)), $verbose );
+
+            ### mark the error ###
+            $fail++;
+            next;
+        }
+
+        ### next, set the default, make sure the key exists in %defs ###
+        $defs{$key} = $tmpl->{'default'}
+                        if exists $tmpl->{'default'};
+
+        if( $SANITY_CHECK_TEMPLATE ) {
+            ### last, check if they provided any weird template keys
+            ### -- do this last so we don't always execute this code.
+            ### just a small optimization.
+            map {   _store_error(
+                        loc(q|Template type '%1' not supported [at key '%2']|,
+                        $_, $key), 1, 0 );
+            } grep {
+                not $known_keys{$_}
+            } keys %$tmpl;
+
+            ### make sure you passed a ref, otherwise, complain about it!
+            if ( exists $tmpl->{'store'} ) {
+                _store_error( loc(
+                    q|Store variable for '%1' is not a reference!|, $key
+                ), 1, 0 ) unless ref $tmpl->{'store'};
+            }
+        }
+
+        push @want_store, $key if $tmpl->{'store'};
+    }
+
+    ### errors found ###
+    return if $fail;
+
+    ### flag to see if anything went wrong ###
+    my $wrong;
+
+    ### flag to see if we warned for anything, needed for warnings_fatal
+    my $warned;
+
+    for my $key (keys %$args) {
+        my $arg = $args->{$key};
+
+        ### you gave us this key, but it's not in the template ###
+        unless( $utmpl->{$key} ) {
+
+            ### but we'll allow it anyway ###
+            if( $ALLOW_UNKNOWN ) {
+                $defs{$key} = $arg;
+
+            ### warn about the error ###
+            } else {
+                _store_error(
+                    loc("Key '%1' is not a valid key for %2 provided by %3",
+                        $key, _who_was_it(), _who_was_it(1)), $verbose);
+                $warned ||= 1;
+            }
+            next;
+        }
+
+        ### copy of this keys template instructions, to save derefs ###
+        my %tmpl = %{$utmpl->{$key}};
+
+        ### check if you're even allowed to override this key ###
+        if( $tmpl{'no_override'} ) {
+            _store_error(
+                loc(q[You are not allowed to override key '%1'].
+                    q[for %2 from %3], $key, _who_was_it(), _who_was_it(1)),
+                $verbose
+            );
+            $warned ||= 1;
+            next;
+        }
+
+        ### check if you were supposed to provide defined() values ###
+        if( ($tmpl{'defined'} || $ONLY_ALLOW_DEFINED) and not defined $arg ) {
+            _store_error(loc(q|Key '%1' must be defined when passed|, $key),
+                $verbose );
+            $wrong ||= 1;
+            next;
+        }
+
+        ### check if they should be of a strict type, and if it is ###
+        if( ($tmpl{'strict_type'} || $STRICT_TYPE) and
+            (ref $arg ne ref $tmpl{'default'})
+        ) {
+            _store_error(loc(q|Key '%1' needs to be of type '%2'|,
+                        $key, ref $tmpl{'default'} || 'SCALAR'), $verbose );
+            $wrong ||= 1;
+            next;
+        }
+
+        ### check if we have an allow handler, to validate against ###
+        ### allow() will report its own errors ###
+        if( exists $tmpl{'allow'} and not do {
+                local $_ERROR_STRING;
+                allow( $arg, $tmpl{'allow'} )
+            }
+        ) {
+            ### stringify the value in the error report -- we don't want dumps
+            ### of objects, but we do want to see *roughly* what we passed
+            _store_error(loc(q|Key '%1' (%2) is of invalid type for '%3' |.
+                             q|provided by %4|,
+                            $key, "$arg", _who_was_it(),
+                            _who_was_it(1)), $verbose);
+            $wrong ||= 1;
+            next;
+        }
+
+        ### we got here, then all must be OK ###
+        $defs{$key} = $arg;
+
+    }
+
+    ### croak with the collected errors if there were errors and
+    ### we have the fatal flag toggled.
+    croak(__PACKAGE__->last_error) if ($wrong || $warned) && $WARNINGS_FATAL;
+
+    ### done with our loop... if $wrong is set, something went wrong
+    ### and the user is already informed, just return...
+    return if $wrong;
+
+    ### check if we need to store any of the keys ###
+    ### can't do it before, because something may go wrong later,
+    ### leaving the user with a few set variables
+    for my $key (@want_store) {
+        next unless exists $defs{$key};
+        my $ref = $utmpl->{$key}{'store'};
+        $$ref = $NO_DUPLICATES ? delete $defs{$key} : $defs{$key};
+    }
+
+    return \%defs;
+}
+
+=head2 allow( $test_me, \@criteria );
+
+The function that handles the C<allow> key in the template is also
+available for independent use.
+
+The function takes as first argument a key to test against, and
+as second argument any form of criteria that are also allowed by
+the C<allow> key in the template.
+
+You can use the following types of values for allow:
+
+=over 4
+
+=item string
+
+The provided argument MUST be equal to the string for the validation
+to pass.
+
+=item regexp
+
+The provided argument MUST match the regular expression for the
+validation to pass.
+
+=item subroutine
+
+The provided subroutine MUST return true in order for the validation
+to pass and the argument accepted.
+
+(This is particularly useful for more complicated data).
+
+=item array ref
+
+The provided argument MUST equal one of the elements of the array
+ref for the validation to pass. An array ref can hold all the above
+values.
+
+=back
+
+It returns true if the key matched the criteria, or false otherwise.
+
+=cut
+
+sub allow {
+    ### use $_[0] and $_[1] since this is hot code... ###
+    #my ($val, $ref) = @_;
+
+    ### it's a regexp ###
+    if( ref $_[1] eq 'Regexp' ) {
+        local $^W;  # silence warnings if $val is undef #
+        return if $_[0] !~ /$_[1]/;
+
+    ### it's a sub ###
+    } elsif ( ref $_[1] eq 'CODE' ) {
+        return unless $_[1]->( $_[0] );
+
+    ### it's an array ###
+    } elsif ( ref $_[1] eq 'ARRAY' ) {
+
+        ### loop over the elements, see if one of them says the
+        ### value is OK
+        ### also, short-circuit when possible
+        for ( @{$_[1]} ) {
+            return 1 if allow( $_[0], $_ );
+        }
+
+        return;
+
+    ### fall back to a simple, but safe 'eq' ###
+    } else {
+        return unless _safe_eq( $_[0], $_[1] );
+    }
+
+    ### we got here, no failures ###
+    return 1;
+}
+
+### helper functions ###
+
+sub _safe_eq {
+    ### only do a straight 'eq' if they're both defined ###
+    return defined($_[0]) && defined($_[1])
+                ? $_[0] eq $_[1]
+                : defined($_[0]) eq defined($_[1]);
+}
+
+sub _who_was_it {
+    my $level = $_[0] || 0;
+
+    return (caller(2 + $CALLER_DEPTH + $level))[3] || 'ANON'
+}
+
+=head2 last_error()
+
+Returns a string containing all warnings and errors reported during
+the last time C<check> was called.
+
+This is useful if you want to report then some other way than
+C<carp>'ing when the verbose flag is on.
+
+It is exported upon request.
+
+=cut
+
+{   $_ERROR_STRING = '';
+
+    sub _store_error {
+        my($err, $verbose, $offset) = @_[0..2];
+        $verbose ||= 0;
+        $offset  ||= 0;
+        my $level   = 1 + $offset;
+
+        local $Carp::CarpLevel = $level;
+
+        carp $err if $verbose;
+
+        $_ERROR_STRING .= $err . "\n";
+    }
+
+    sub _clear_error {
+        $_ERROR_STRING = '';
+    }
+
+    sub last_error { $_ERROR_STRING }
+}
+
+1;
+
+=head1 Global Variables
+
+The behaviour of Params::Check can be altered by changing the
+following global variables:
+
+=head2 $Params::Check::VERBOSE
+
+This controls whether Params::Check will issue warnings and
+explanations as to why certain things may have failed.
+If you set it to 0, Params::Check will not output any warnings.
+
+The default is 1 when L<warnings> are enabled, 0 otherwise;
+
+=head2 $Params::Check::STRICT_TYPE
+
+This works like the C<strict_type> option you can pass to C<check>,
+which will turn on C<strict_type> globally for all calls to C<check>.
+
+The default is 0;
+
+=head2 $Params::Check::ALLOW_UNKNOWN
+
+If you set this flag, unknown options will still be present in the
+return value, rather than filtered out. This is useful if your
+subroutine is only interested in a few arguments, and wants to pass
+the rest on blindly to perhaps another subroutine.
+
+The default is 0;
+
+=head2 $Params::Check::STRIP_LEADING_DASHES
+
+If you set this flag, all keys passed in the following manner:
+
+    function( -key => 'val' );
+
+will have their leading dashes stripped.
+
+=head2 $Params::Check::NO_DUPLICATES
+
+If set to true, all keys in the template that are marked as to be
+stored in a scalar, will also be removed from the result set.
+
+Default is false, meaning that when you use C<store> as a template
+key, C<check> will put it both in the scalar you supplied, as well as
+in the hashref it returns.
+
+=head2 $Params::Check::PRESERVE_CASE
+
+If set to true, L<Params::Check> will no longer convert all keys from
+the user input to lowercase, but instead expect them to be in the
+case the template provided. This is useful when you want to use
+similar keys with different casing in your templates.
+
+Understand that this removes the case-insensitivity feature of this
+module.
+
+Default is 0;
+
+=head2 $Params::Check::ONLY_ALLOW_DEFINED
+
+If set to true, L<Params::Check> will require all values passed to be
+C<defined>. If you wish to enable this on a 'per key' basis, use the
+template option C<defined> instead.
+
+Default is 0;
+
+=head2 $Params::Check::SANITY_CHECK_TEMPLATE
+
+If set to true, L<Params::Check> will sanity check templates, validating
+for errors and unknown keys. Although very useful for debugging, this
+can be somewhat slow in hot-code and large loops.
+
+To disable this check, set this variable to C<false>.
+
+Default is 1;
+
+=head2 $Params::Check::WARNINGS_FATAL
+
+If set to true, L<Params::Check> will C<croak> when an error during
+template validation occurs, rather than return C<false>.
+
+Default is 0;
+
+=head2 $Params::Check::CALLER_DEPTH
+
+This global modifies the argument given to C<caller()> by
+C<Params::Check::check()> and is useful if you have a custom wrapper
+function around C<Params::Check::check()>. The value must be an
+integer, indicating the number of wrapper functions inserted between
+the real function call and C<Params::Check::check()>.
+
+Example wrapper function, using a custom stacktrace:
+
+    sub check {
+        my ($template, $args_in) = @_;
+
+        local $Params::Check::WARNINGS_FATAL = 1;
+        local $Params::Check::CALLER_DEPTH = $Params::Check::CALLER_DEPTH + 1;
+        my $args_out = Params::Check::check($template, $args_in);
+
+        my_stacktrace(Params::Check::last_error) unless $args_out;
+
+        return $args_out;
+    }
+
+Default is 0;
+
+=head1 Acknowledgements
+
+Thanks to Richard Soderberg for his performance improvements.
+
+=head1 BUG REPORTS
+
+Please report bugs or other issues to E<lt>bug-params-check@rt.cpan.orgE<gt>.
+
+=head1 AUTHOR
+
+This module by Jos Boumans E<lt>kane@cpan.orgE<gt>.
+
+=head1 COPYRIGHT
+
+This library is free software; you may redistribute and/or modify it
+under the same terms as Perl itself.
+
+
+=cut
+
+# Local variables:
+# c-indentation-style: bsd
+# c-basic-offset: 4
+# indent-tabs-mode: nil
+# End:
+# vim: expandtab shiftwidth=4:

git/usr/share/perl5/core_perl/Perl/OSType.pm

@@ -0,0 +1,225 @@
+use strict;
+use warnings;
+
+package Perl::OSType;
+# ABSTRACT: Map Perl operating system names to generic types
+
+our $VERSION = '1.010';
+
+require Exporter;
+our @ISA = qw(Exporter);
+
+our %EXPORT_TAGS = ( all => [qw( os_type is_os_type )] );
+
+our @EXPORT_OK = @{ $EXPORT_TAGS{all} };
+
+# originally taken from Module::Build by Ken Williams et al.
+my %OSTYPES = qw(
+  aix         Unix
+  bsdos       Unix
+  beos        Unix
+  bitrig      Unix
+  dgux        Unix
+  dragonfly   Unix
+  dynixptx    Unix
+  freebsd     Unix
+  linux       Unix
+  haiku       Unix
+  hpux        Unix
+  iphoneos    Unix
+  irix        Unix
+  darwin      Unix
+  machten     Unix
+  midnightbsd Unix
+  minix       Unix
+  mirbsd      Unix
+  next        Unix
+  openbsd     Unix
+  netbsd      Unix
+  dec_osf     Unix
+  nto         Unix
+  svr4        Unix
+  svr5        Unix
+  sco         Unix
+  sco_sv      Unix
+  unicos      Unix
+  unicosmk    Unix
+  solaris     Unix
+  sunos       Unix
+  cygwin      Unix
+  msys        Unix
+  os2         Unix
+  interix     Unix
+  gnu         Unix
+  gnukfreebsd Unix
+  nto         Unix
+  qnx         Unix
+  android     Unix
+
+  dos         Windows
+  MSWin32     Windows
+
+  os390       EBCDIC
+  os400       EBCDIC
+  posix-bc    EBCDIC
+  vmesa       EBCDIC
+
+  MacOS       MacOS
+  VMS         VMS
+  vos         VOS
+  riscos      RiscOS
+  amigaos     Amiga
+  mpeix       MPEiX
+);
+
+sub os_type {
+    my ($os) = @_;
+    $os = $^O unless defined $os;
+    return $OSTYPES{$os} || q{};
+}
+
+sub is_os_type {
+    my ( $type, $os ) = @_;
+    return unless $type;
+    $os = $^O unless defined $os;
+    return os_type($os) eq $type;
+}
+
+1;
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Perl::OSType - Map Perl operating system names to generic types
+
+=head1 VERSION
+
+version 1.010
+
+=head1 SYNOPSIS
+
+  use Perl::OSType ':all';
+
+  $current_type = os_type();
+  $other_type = os_type('dragonfly'); # gives 'Unix'
+
+=head1 DESCRIPTION
+
+Modules that provide OS-specific behaviors often need to know if
+the current operating system matches a more generic type of
+operating systems. For example, 'linux' is a type of 'Unix' operating system
+and so is 'freebsd'.
+
+This module provides a mapping between an operating system name as given by
+C<$^O> and a more generic type.  The initial version is based on the OS type
+mappings provided in L<Module::Build> and L<ExtUtils::CBuilder>.  (Thus,
+Microsoft operating systems are given the type 'Windows' rather than 'Win32'.)
+
+=head1 USAGE
+
+No functions are exported by default. The export tag ":all" will export
+all functions listed below.
+
+=head2 os_type()
+
+  $os_type = os_type();
+  $os_type = os_type('MSWin32');
+
+Returns a single, generic OS type for a given operating system name.  With no
+arguments, returns the OS type for the current value of C<$^O>.  If the
+operating system is not recognized, the function will return the empty string.
+
+=head2 is_os_type()
+
+  $is_windows = is_os_type('Windows');
+  $is_unix    = is_os_type('Unix', 'dragonfly');
+
+Given an OS type and OS name, returns true or false if the OS name is of the
+given type.  As with C<os_type>, it will use the current operating system as a
+default if no OS name is provided.
+
+=head1 SEE ALSO
+
+=over 4
+
+=item *
+
+L<Devel::CheckOS>
+
+=back
+
+=for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan
+
+=head1 SUPPORT
+
+=head2 Bugs / Feature Requests
+
+Please report any bugs or feature requests through the issue tracker
+at L<https://github.com/Perl-Toolchain-Gang/Perl-OSType/issues>.
+You will be notified automatically of any progress on your issue.
+
+=head2 Source Code
+
+This is open source software.  The code repository is available for
+public review and contribution under the terms of the license.
+
+L<https://github.com/Perl-Toolchain-Gang/Perl-OSType>
+
+  git clone https://github.com/Perl-Toolchain-Gang/Perl-OSType.git
+
+=head1 AUTHOR
+
+David Golden <dagolden@cpan.org>
+
+=head1 CONTRIBUTORS
+
+=for stopwords Chris 'BinGOs' Williams David Golden Graham Ollis Jonas B. Nielsen Owain G. Ainsworth Paul Green Piotr Roszatycki
+
+=over 4
+
+=item *
+
+Chris 'BinGOs' Williams <chris@bingosnet.co.uk>
+
+=item *
+
+David Golden <xdg@xdg.me>
+
+=item *
+
+Graham Ollis <plicease@cpan.org>
+
+=item *
+
+Jonas B. Nielsen <jonasbn@hoarfrost.local>
+
+=item *
+
+Owain G. Ainsworth <oga@nicotinebsd.org>
+
+=item *
+
+Paul Green <Paul.Green@stratus.com>
+
+=item *
+
+Piotr Roszatycki <piotr.roszatycki@gmail.com>
+
+=back
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is copyright (c) 2016 by David Golden.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+=cut
+
+__END__
+
+
+# vim: ts=4 sts=4 sw=4 et:

git/usr/share/perl5/core_perl/PerlIO/scalar.pm

@@ -0,0 +1,41 @@
+package PerlIO::scalar;
+our $VERSION = '0.32';
+1;
+__END__
+
+=head1 NAME
+
+PerlIO::scalar - in-memory IO, scalar IO
+
+=head1 SYNOPSIS
+
+   my $scalar = '';
+   ...
+   open my $fh, "<",  \$scalar or die;
+   open my $fh, ">",  \$scalar or die;
+   open my $fh, ">>", \$scalar or die;
+
+or
+
+   my $scalar = '';
+   ...
+   open my $fh, "<:scalar",  \$scalar or die;
+   open my $fh, ">:scalar",  \$scalar or die;
+   open my $fh, ">>:scalar", \$scalar or die;
+
+=head1 DESCRIPTION
+
+A filehandle is opened but the file operations are performed "in-memory"
+on a scalar variable.  All the normal file operations can be performed
+on the handle. The scalar is considered a stream of bytes.  Currently
+fileno($fh) returns -1.
+
+Attempting to open a read-only scalar for writing will fail, and if
+warnings are enabled, produce a warning.
+
+=head1 IMPLEMENTATION NOTE
+
+C<PerlIO::scalar> only exists as a stub. One does not need to explicitly
+C<use PerlIO::scalar>.
+
+=cut

git/usr/share/perl5/core_perl/Search/Dict.pm

@@ -0,0 +1,127 @@
+package Search::Dict;
+use strict;
+use Exporter;
+
+BEGIN {
+    if ("$]" >= 5.015008) {
+        require feature;
+        'feature'->import('fc'); # string avoids warning on old Perls <sigh>
+    } else {
+        # ($) prototype, not (_), for perl 5.8 compatibility, just in case
+        *fc = sub ($) { lc $_[0] };
+    }
+}
+
+our $VERSION = '1.08';
+our @ISA = qw(Exporter);
+our @EXPORT = qw(look);
+
+=head1 NAME
+
+Search::Dict - look - search for key in dictionary file
+
+=head1 SYNOPSIS
+
+    use Search::Dict;
+    look *FILEHANDLE, $key, $dict, $fold;
+
+    use Search::Dict;
+    look *FILEHANDLE, $key, $params;
+
+=head1 DESCRIPTION
+
+Sets file position in FILEHANDLE to be first line greater than or equal
+(stringwise) to I<$key>.  Returns the new file position, or -1 if an error
+occurs.
+
+The flags specify dictionary order and case folding:
+
+If I<$dict> is true, search by dictionary order (ignore anything but word
+characters and whitespace).  The default is honour all characters.
+
+If I<$fold> is true, ignore case.  The default is to honour case.
+
+If there are only three arguments and the third argument is a hash
+reference, the keys of that hash can have values C<dict>, C<fold>, and
+C<comp> or C<xfrm> (see below), and their corresponding values will be
+used as the parameters.
+
+If a comparison subroutine (comp) is defined, it must return less than zero,
+zero, or greater than zero, if the first comparand is less than,
+equal, or greater than the second comparand.
+
+If a transformation subroutine (xfrm) is defined, its value is used to
+transform the lines read from the filehandle before their comparison.
+
+=cut
+
+sub look {
+    my($fh,$key,$dict,$fold) = @_;
+    my ($comp, $xfrm);
+    if (@_ == 3 && ref $dict eq 'HASH') {
+	my $params = $dict;
+	$dict = 0;
+	$dict = $params->{dict} if exists $params->{dict};
+	$fold = $params->{fold} if exists $params->{fold};
+	$comp = $params->{comp} if exists $params->{comp};
+	$xfrm = $params->{xfrm} if exists $params->{xfrm};
+    }
+    $comp = sub { $_[0] cmp $_[1] } unless defined $comp;
+    local($_);
+    my $fno = fileno $fh;
+    my @stat;
+    if ( defined $fno && $fno >= 0 && ! tied *{$fh} ) { # real, open file
+      @stat = eval { stat($fh) }; # in case fileno lies
+    }
+    my($size, $blksize) = @stat[7,11];
+    $size = do { seek($fh,0,2); my $s = tell($fh); seek($fh,0,0); $s }
+        unless defined $size;
+    $blksize ||= 8192;
+    $key =~ s/[^\w\s]//g if $dict;
+    if ( $fold ) {
+      $key = fc($key);
+    }
+    # find the right block
+    my($min, $max) = (0, int($size / $blksize));
+    my $mid;
+    while ($max - $min > 1) {
+	$mid = int(($max + $min) / 2);
+	seek($fh, $mid * $blksize, 0)
+	    or return -1;
+	<$fh> if $mid;			# probably a partial line
+	$_ = <$fh>;
+	$_ = $xfrm->($_) if defined $xfrm;
+	chomp;
+	s/[^\w\s]//g if $dict;
+        if ( $fold ) {
+          $_ = fc($_);
+        }
+	if (defined($_) && $comp->($_, $key) < 0) {
+	    $min = $mid;
+	}
+	else {
+	    $max = $mid;
+	}
+    }
+    # find the right line
+    $min *= $blksize;
+    seek($fh,$min,0)
+	or return -1;
+    <$fh> if $min;
+    for (;;) {
+	$min = tell($fh);
+	defined($_ = <$fh>)
+	    or last;
+	$_ = $xfrm->($_) if defined $xfrm;
+	chomp;
+	s/[^\w\s]//g if $dict;
+        if ( $fold ) {
+          $_ = fc($_);
+        }
+	last if $comp->($_, $key) >= 0;
+    }
+    seek($fh,$min,0);
+    $min;
+}
+
+1;

git/usr/share/perl5/core_perl/Term/ANSIColor.pm

@@ -0,0 +1,1414 @@
+# Color screen output using ANSI escape sequences.
+#
+# This module provides utility functions (in two different forms) for coloring
+# output with ANSI escape sequences.
+#
+# This module is sometimes used in low-memory environments, so avoid use of
+# \d, \w, [:upper:], and similar constructs in the most important functions
+# (color, colored, AUTOLOAD, and the generated constant functions) since
+# loading the Unicode attribute files consumes a lot of memory.
+#
+# Ah, September, when the sysadmins turn colors and fall off the trees....
+#                               -- Dave Van Domelen
+#
+# SPDX-License-Identifier: GPL-1.0-or-later OR Artistic-1.0-Perl
+
+##############################################################################
+# Modules and declarations
+##############################################################################
+
+package Term::ANSIColor;
+
+use 5.008;
+use strict;
+use warnings;
+
+# Also uses Carp but loads it on demand to reduce memory usage.
+
+use Exporter;
+
+# use Exporter plus @ISA instead of use base to reduce memory usage.
+## no critic (ClassHierarchies::ProhibitExplicitISA)
+
+# Declare variables that should be set in BEGIN for robustness.
+## no critic (Modules::ProhibitAutomaticExportation)
+our (@EXPORT, @EXPORT_OK, %EXPORT_TAGS, @ISA, $VERSION);
+
+# We use autoloading, which sets this variable to the name of the called sub.
+our $AUTOLOAD;
+
+# Set $VERSION and everything export-related in a BEGIN block for robustness
+# against circular module loading (not that we load any modules, but
+# consistency is good).
+BEGIN {
+    $VERSION = '5.01';
+
+    # All of the basic supported constants, used in %EXPORT_TAGS.
+    my @colorlist = qw(
+      CLEAR           RESET             BOLD            DARK
+      FAINT           ITALIC            UNDERLINE       UNDERSCORE
+      BLINK           REVERSE           CONCEALED
+
+      BLACK           RED               GREEN           YELLOW
+      BLUE            MAGENTA           CYAN            WHITE
+      ON_BLACK        ON_RED            ON_GREEN        ON_YELLOW
+      ON_BLUE         ON_MAGENTA        ON_CYAN         ON_WHITE
+
+      BRIGHT_BLACK    BRIGHT_RED        BRIGHT_GREEN    BRIGHT_YELLOW
+      BRIGHT_BLUE     BRIGHT_MAGENTA    BRIGHT_CYAN     BRIGHT_WHITE
+      ON_BRIGHT_BLACK ON_BRIGHT_RED     ON_BRIGHT_GREEN ON_BRIGHT_YELLOW
+      ON_BRIGHT_BLUE  ON_BRIGHT_MAGENTA ON_BRIGHT_CYAN  ON_BRIGHT_WHITE
+    );
+
+    # 256-color constants, used in %EXPORT_TAGS.
+    my @colorlist256 = (
+        (map { ("ANSI$_", "ON_ANSI$_") } 0 .. 255),
+        (map { ("GREY$_", "ON_GREY$_") } 0 .. 23),
+    );
+    for my $r (0 .. 5) {
+        for my $g (0 .. 5) {
+            push(@colorlist256, map { ("RGB$r$g$_", "ON_RGB$r$g$_") } 0 .. 5);
+        }
+    }
+
+    # Exported symbol configuration.
+    @ISA         = qw(Exporter);
+    @EXPORT      = qw(color colored);
+    @EXPORT_OK   = qw(uncolor colorstrip colorvalid coloralias);
+    %EXPORT_TAGS = (
+        constants    => \@colorlist,
+        constants256 => \@colorlist256,
+        pushpop      => [@colorlist, qw(PUSHCOLOR POPCOLOR LOCALCOLOR)],
+    );
+    Exporter::export_ok_tags('pushpop', 'constants256');
+}
+
+##############################################################################
+# Package variables
+##############################################################################
+
+# If this is set, any color changes will implicitly push the current color
+# onto the stack and then pop it at the end of the constant sequence, just as
+# if LOCALCOLOR were used.
+our $AUTOLOCAL;
+
+# Caller sets this to force a reset at the end of each constant sequence.
+our $AUTORESET;
+
+# Caller sets this to force colors to be reset at the end of each line.
+our $EACHLINE;
+
+##############################################################################
+# Internal data structures
+##############################################################################
+
+# This module does quite a bit of initialization at the time it is first
+# loaded, primarily to set up the package-global %ATTRIBUTES hash.  The
+# entries for 256-color names are easier to handle programmatically, and
+# custom colors are also imported from the environment if any are set.
+
+# All basic supported attributes, including aliases.
+#<<<
+our %ATTRIBUTES = (
+    'clear'          => 0,
+    'reset'          => 0,
+    'bold'           => 1,
+    'dark'           => 2,
+    'faint'          => 2,
+    'italic'         => 3,
+    'underline'      => 4,
+    'underscore'     => 4,
+    'blink'          => 5,
+    'reverse'        => 7,
+    'concealed'      => 8,
+
+    'black'          => 30,   'on_black'          => 40,
+    'red'            => 31,   'on_red'            => 41,
+    'green'          => 32,   'on_green'          => 42,
+    'yellow'         => 33,   'on_yellow'         => 43,
+    'blue'           => 34,   'on_blue'           => 44,
+    'magenta'        => 35,   'on_magenta'        => 45,
+    'cyan'           => 36,   'on_cyan'           => 46,
+    'white'          => 37,   'on_white'          => 47,
+
+    'bright_black'   => 90,   'on_bright_black'   => 100,
+    'bright_red'     => 91,   'on_bright_red'     => 101,
+    'bright_green'   => 92,   'on_bright_green'   => 102,
+    'bright_yellow'  => 93,   'on_bright_yellow'  => 103,
+    'bright_blue'    => 94,   'on_bright_blue'    => 104,
+    'bright_magenta' => 95,   'on_bright_magenta' => 105,
+    'bright_cyan'    => 96,   'on_bright_cyan'    => 106,
+    'bright_white'   => 97,   'on_bright_white'   => 107,
+);
+#>>>
+
+# Generating the 256-color codes involves a lot of codes and offsets that are
+# not helped by turning them into constants.
+
+# The first 16 256-color codes are duplicates of the 16 ANSI colors.  The rest
+# are RBG and greyscale values.
+for my $code (0 .. 15) {
+    $ATTRIBUTES{"ansi$code"}    = "38;5;$code";
+    $ATTRIBUTES{"on_ansi$code"} = "48;5;$code";
+}
+
+# 256-color RGB colors.  Red, green, and blue can each be values 0 through 5,
+# and the resulting 216 colors start with color 16.
+for my $r (0 .. 5) {
+    for my $g (0 .. 5) {
+        for my $b (0 .. 5) {
+            my $code = 16 + (6 * 6 * $r) + (6 * $g) + $b;
+            $ATTRIBUTES{"rgb$r$g$b"}    = "38;5;$code";
+            $ATTRIBUTES{"on_rgb$r$g$b"} = "48;5;$code";
+        }
+    }
+}
+
+# The last 256-color codes are 24 shades of grey.
+for my $n (0 .. 23) {
+    my $code = $n + 232;
+    $ATTRIBUTES{"grey$n"}    = "38;5;$code";
+    $ATTRIBUTES{"on_grey$n"} = "48;5;$code";
+}
+
+# Reverse lookup.  Alphabetically first name for a sequence is preferred.
+our %ATTRIBUTES_R;
+for my $attr (reverse(sort(keys(%ATTRIBUTES)))) {
+    $ATTRIBUTES_R{ $ATTRIBUTES{$attr} } = $attr;
+}
+
+# Provide ansiN names for all 256 characters to provide a convenient flat
+# namespace if one doesn't want to mess with the RGB and greyscale naming.  Do
+# this after creating %ATTRIBUTES_R since we want to use the canonical names
+# when reversing a color.
+for my $code (16 .. 255) {
+    $ATTRIBUTES{"ansi$code"}    = "38;5;$code";
+    $ATTRIBUTES{"on_ansi$code"} = "48;5;$code";
+}
+
+# Import any custom colors set in the environment.
+our %ALIASES;
+if (exists($ENV{ANSI_COLORS_ALIASES})) {
+    my $spec = $ENV{ANSI_COLORS_ALIASES};
+    $spec =~ s{ \A \s+ }{}xms;
+    $spec =~ s{ \s+ \z }{}xms;
+
+    # Error reporting here is an interesting question.  Use warn rather than
+    # carp because carp would report the line of the use or require, which
+    # doesn't help anyone understand what's going on, whereas seeing this code
+    # will be more helpful.
+    ## no critic (ErrorHandling::RequireCarping)
+    for my $definition (split(m{\s*,\s*}xms, $spec)) {
+        my ($new, $old) = split(m{\s*=\s*}xms, $definition, 2);
+        if (!$new || !$old) {
+            warn qq{Bad color mapping "$definition"};
+        } else {
+            my $result = eval { coloralias($new, $old) };
+            if (!$result) {
+                my $error = $@;
+                $error =~ s{ [ ] at [ ] .* }{}xms;
+                warn qq{$error in "$definition"};
+            }
+        }
+    }
+}
+
+# Stores the current color stack maintained by PUSHCOLOR and POPCOLOR.  This
+# is global and therefore not threadsafe.
+our @COLORSTACK;
+
+##############################################################################
+# Helper functions
+##############################################################################
+
+# Stub to load the Carp module on demand.
+sub croak {
+    my (@args) = @_;
+    require Carp;
+    Carp::croak(@args);
+}
+
+##############################################################################
+# Implementation (constant form)
+##############################################################################
+
+# Time to have fun!  We now want to define the constant subs, which are named
+# the same as the attributes above but in all caps.  Each constant sub needs
+# to act differently depending on whether $AUTORESET is set.  Without
+# autoreset:
+#
+#     BLUE "text\n"  ==>  "\e[34mtext\n"
+#
+# If $AUTORESET is set, we should instead get:
+#
+#     BLUE "text\n"  ==>  "\e[34mtext\n\e[0m"
+#
+# The sub also needs to handle the case where it has no arguments correctly.
+# Maintaining all of this as separate subs would be a major nightmare, as well
+# as duplicate the %ATTRIBUTES hash, so instead we define an AUTOLOAD sub to
+# define the constant subs on demand.  To do that, we check the name of the
+# called sub against the list of attributes, and if it's an all-caps version
+# of one of them, we define the sub on the fly and then run it.
+#
+# If the environment variable ANSI_COLORS_DISABLED is set to a true value, or
+# if the variable NO_COLOR is set, just return the arguments without adding
+# any escape sequences.  This is to make it easier to write scripts that also
+# work on systems without any ANSI support, like Windows consoles.
+#
+# Avoid using character classes like [:upper:] and \w here, since they load
+# Unicode character tables and consume a ton of memory.  All of our constants
+# only use ASCII characters.
+#
+## no critic (ClassHierarchies::ProhibitAutoloading)
+## no critic (Subroutines::RequireArgUnpacking)
+## no critic (RegularExpressions::ProhibitEnumeratedClasses)
+sub AUTOLOAD {
+    my ($sub, $attr) = $AUTOLOAD =~ m{
+        \A ( [a-zA-Z0-9:]* :: ([A-Z0-9_]+) ) \z
+    }xms;
+
+    # Check if we were called with something that doesn't look like an
+    # attribute.
+    if (!($attr && defined($ATTRIBUTES{ lc $attr }))) {
+        croak("undefined subroutine &$AUTOLOAD called");
+    }
+
+    # If colors are disabled, just return the input.  Do this without
+    # installing a sub for (marginal, unbenchmarked) speed.
+    if ($ENV{ANSI_COLORS_DISABLED} || defined($ENV{NO_COLOR})) {
+        return join(q{}, @_);
+    }
+
+    # We've untainted the name of the sub.
+    $AUTOLOAD = $sub;
+
+    # Figure out the ANSI string to set the desired attribute.
+    my $escape = "\e[" . $ATTRIBUTES{ lc $attr } . 'm';
+
+    # Save the current value of $@.  We can't just use local since we want to
+    # restore it before dispatching to the newly-created sub.  (The caller may
+    # be colorizing output that includes $@.)
+    my $eval_err = $@;
+
+    # Generate the constant sub, which should still recognize some of our
+    # package variables.  Use string eval to avoid a dependency on
+    # Sub::Install, even though it makes it somewhat less readable.
+    ## no critic (BuiltinFunctions::ProhibitStringyEval)
+    ## no critic (ValuesAndExpressions::ProhibitImplicitNewlines)
+    my $eval_result = eval qq{
+        sub $AUTOLOAD {
+            if (\$ENV{ANSI_COLORS_DISABLED} || defined(\$ENV{NO_COLOR})) {
+                return join(q{}, \@_);
+            } elsif (\$AUTOLOCAL && \@_) {
+                return PUSHCOLOR('$escape') . join(q{}, \@_) . POPCOLOR;
+            } elsif (\$AUTORESET && \@_) {
+                return '$escape' . join(q{}, \@_) . "\e[0m";
+            } else {
+                return '$escape' . join(q{}, \@_);
+            }
+        }
+        1;
+    };
+
+    # Failure is an internal error, not a problem with the caller.
+    ## no critic (ErrorHandling::RequireCarping)
+    if (!$eval_result) {
+        die "failed to generate constant $attr: $@";
+    }
+
+    # Restore $@.
+    ## no critic (Variables::RequireLocalizedPunctuationVars)
+    $@ = $eval_err;
+
+    # Dispatch to the newly-created sub.
+    goto &$AUTOLOAD;
+}
+## use critic
+
+# Append a new color to the top of the color stack and return the top of
+# the stack.
+#
+# $text - Any text we're applying colors to, with color escapes prepended
+#
+# Returns: The text passed in
+sub PUSHCOLOR {
+    my (@text) = @_;
+    my $text = join(q{}, @text);
+
+    # Extract any number of color-setting escape sequences from the start of
+    # the string.
+    my ($color) = $text =~ m{ \A ( (?:\e\[ [\d;]+ m)+ ) }xms;
+
+    # If we already have a stack, append these escapes to the set from the top
+    # of the stack.  This way, each position in the stack stores the complete
+    # enabled colors for that stage, at the cost of some potential
+    # inefficiency.
+    if (@COLORSTACK) {
+        $color = $COLORSTACK[-1] . $color;
+    }
+
+    # Push the color onto the stack.
+    push(@COLORSTACK, $color);
+    return $text;
+}
+
+# Pop the color stack and return the new top of the stack (or reset, if
+# the stack is empty).
+#
+# @text - Any text we're applying colors to
+#
+# Returns: The concatenation of @text prepended with the new stack color
+sub POPCOLOR {
+    my (@text) = @_;
+    pop(@COLORSTACK);
+    if (@COLORSTACK) {
+        return $COLORSTACK[-1] . join(q{}, @text);
+    } else {
+        return RESET(@text);
+    }
+}
+
+# Surround arguments with a push and a pop.  The effect will be to reset the
+# colors to whatever was on the color stack before this sequence of colors was
+# applied.
+#
+# @text - Any text we're applying colors to
+#
+# Returns: The concatenation of the text and the proper color reset sequence.
+sub LOCALCOLOR {
+    my (@text) = @_;
+    return PUSHCOLOR(join(q{}, @text)) . POPCOLOR();
+}
+
+##############################################################################
+# Implementation (attribute string form)
+##############################################################################
+
+# Return the escape code for a given set of color attributes.
+#
+# @codes - A list of possibly space-separated color attributes
+#
+# Returns: The escape sequence setting those color attributes
+#          undef if no escape sequences were given
+#  Throws: Text exception for any invalid attribute
+sub color {
+    my (@codes) = @_;
+
+    # Return the empty string if colors are disabled.
+    if ($ENV{ANSI_COLORS_DISABLED} || defined($ENV{NO_COLOR})) {
+        return q{};
+    }
+
+    # Split on whitespace and expand aliases.
+    @codes = map { split } @codes;
+    @codes = map { defined($ALIASES{$_}) ? @{ $ALIASES{$_} } : $_ } @codes;
+
+    # Build the attribute string from semicolon-separated numbers.
+    ## no critic (RegularExpressions::ProhibitEnumeratedClasses)
+    my $attribute = q{};
+    for my $code (@codes) {
+        $code = lc($code);
+        if (defined($ATTRIBUTES{$code})) {
+            $attribute .= $ATTRIBUTES{$code} . q{;};
+        } elsif ($code =~ m{ \A (on_)? r([0-9]+) g([0-9]+) b([0-9]+) \z }xms) {
+            my ($r, $g, $b) = ($2 + 0, $3 + 0, $4 + 0);
+            if ($r > 255 || $g > 255 || $b > 255) {
+                croak("Invalid attribute name $code");
+            }
+            my $prefix = $1 ? '48' : '38';
+            $attribute .= "$prefix;2;$r;$g;$b;";
+        } else {
+            croak("Invalid attribute name $code");
+        }
+    }
+    ## use critic
+
+    # We added one too many semicolons for simplicity.  Remove the last one.
+    chop($attribute);
+
+    # Return undef if there were no attributes.
+    return ($attribute ne q{}) ? "\e[${attribute}m" : undef;
+}
+
+# Return a list of named color attributes for a given set of escape codes.
+# Escape sequences can be given with or without enclosing "\e[" and "m".  The
+# empty escape sequence '' or "\e[m" gives an empty list of attrs.
+#
+# There is one special case.  256-color codes start with 38 or 48, followed by
+# a 5 and then the 256-color code.
+#
+# @escapes - A list of escape sequences or escape sequence numbers
+#
+# Returns: An array of attribute names corresponding to those sequences
+#  Throws: Text exceptions on invalid escape sequences or unknown colors
+sub uncolor {
+    my (@escapes) = @_;
+    my (@nums, @result);
+
+    # Walk the list of escapes and build a list of attribute numbers.
+    for my $escape (@escapes) {
+        $escape =~ s{ \A \e\[ }{}xms;
+        $escape =~ s{ m \z }   {}xms;
+        my ($attrs) = $escape =~ m{ \A ((?:\d+;)* \d*) \z }xms;
+        if (!defined($attrs)) {
+            croak("Bad escape sequence $escape");
+        }
+
+        # Pull off 256-color codes (38;5;n or 48;5;n) and true color codes
+        # (38;2;n;n;n or 48;2;n;n;n) as a unit.
+        my $regex = qr{
+            (
+                0*[34]8 ; 0*2 ; \d+ ; \d+ ; \d+
+              | 0*[34]8 ; 0*5 ; \d+
+              | \d+
+            )
+            (?: ; | \z )
+        }xms;
+        push(@nums, $attrs =~ m{$regex}xmsg);
+    }
+
+    # Now, walk the list of numbers and convert them to attribute names.
+    # Strip leading zeroes from any of the numbers.  (xterm, at least, allows
+    # leading zeroes to be added to any number in an escape sequence.)
+    for my $num (@nums) {
+        if ($num =~ m{ \A 0*([34])8 ; 0*2 ; (\d+) ; (\d+) ; (\d+) \z }xms) {
+            my ($r, $g, $b) = ($2 + 0, $3 + 0, $4 + 0);
+            if ($r > 255 || $g > 255 || $b > 255) {
+                croak("No name for escape sequence $num");
+            }
+            my $prefix = ($1 == 4) ? 'on_' : q{};
+            push(@result, "${prefix}r${r}g${g}b${b}");
+        } else {
+            $num =~ s{ ( \A | ; ) 0+ (\d) }{$1$2}xmsg;
+            my $name = $ATTRIBUTES_R{$num};
+            if (!defined($name)) {
+                croak("No name for escape sequence $num");
+            }
+            push(@result, $name);
+        }
+    }
+
+    # Return the attribute names.
+    return @result;
+}
+
+# Given a string and a set of attributes, returns the string surrounded by
+# escape codes to set those attributes and then clear them at the end of the
+# string.  The attributes can be given either as an array ref as the first
+# argument or as a list as the second and subsequent arguments.
+#
+# If $EACHLINE is set, insert a reset before each occurrence of the string
+# $EACHLINE and the starting attribute code after the string $EACHLINE, so
+# that no attribute crosses line delimiters (this is often desirable if the
+# output is to be piped to a pager or some other program).
+#
+# $first - An anonymous array of attributes or the text to color
+# @rest  - The text to color or the list of attributes
+#
+# Returns: The text, concatenated if necessary, surrounded by escapes to set
+#          the desired colors and reset them afterwards
+#  Throws: Text exception on invalid attributes
+sub colored {
+    my ($first, @rest) = @_;
+    my ($string, @codes);
+    if (ref($first) && ref($first) eq 'ARRAY') {
+        @codes  = @{$first};
+        $string = join(q{}, @rest);
+    } else {
+        $string = $first;
+        @codes  = @rest;
+    }
+
+    # Return the string unmolested if colors are disabled.
+    if ($ENV{ANSI_COLORS_DISABLED} || defined($ENV{NO_COLOR})) {
+        return $string;
+    }
+
+    # Find the attribute string for our colors.
+    my $attr = color(@codes);
+
+    # If $EACHLINE is defined, split the string on line boundaries, suppress
+    # empty segments, and then colorize each of the line sections.
+    if (defined($EACHLINE)) {
+        my @text = map { ($_ ne $EACHLINE) ? $attr . $_ . "\e[0m" : $_ }
+          grep { length > 0 }
+          split(m{ (\Q$EACHLINE\E) }xms, $string);
+        return join(q{}, @text);
+    } else {
+        return $attr . $string . "\e[0m";
+    }
+}
+
+# Define a new color alias, or return the value of an existing alias.
+#
+# $alias - The color alias to define
+# @color - The color attributes the alias will correspond to (optional)
+#
+# Returns: The standard color value of the alias as a string (may be multiple
+#              attributes separated by spaces)
+#          undef if one argument was given and the alias was not recognized
+#  Throws: Text exceptions for invalid alias names, attempts to use a
+#          standard color name as an alias, or an unknown standard color name
+sub coloralias {
+    my ($alias, @color) = @_;
+    if (!@color) {
+        if (exists($ALIASES{$alias})) {
+            return join(q{ }, @{ $ALIASES{$alias} });
+        } else {
+            return;
+        }
+    }
+
+    # Avoid \w here to not load Unicode character tables, which increases the
+    # memory footprint of this module considerably.
+    #
+    ## no critic (RegularExpressions::ProhibitEnumeratedClasses)
+    if ($alias !~ m{ \A [a-zA-Z0-9._-]+ \z }xms) {
+        croak(qq{Invalid alias name "$alias"});
+    } elsif ($ATTRIBUTES{$alias}) {
+        croak(qq{Cannot alias standard color "$alias"});
+    }
+    ## use critic
+
+    # Split on whitespace and expand aliases.
+    @color = map { split } @color;
+    @color = map { defined($ALIASES{$_}) ? @{ $ALIASES{$_} } : $_ } @color;
+
+    # Check that all of the attributes are valid.
+    for my $attribute (@color) {
+        if (!exists($ATTRIBUTES{$attribute})) {
+            croak(qq{Invalid attribute name "$attribute"});
+        }
+    }
+
+    # Set the alias and return.
+    $ALIASES{$alias} = [@color];
+    return join(q{ }, @color);
+}
+
+# Given a string, strip the ANSI color codes out of that string and return the
+# result.  This removes only ANSI color codes, not movement codes and other
+# escape sequences.
+#
+# @string - The list of strings to sanitize
+#
+# Returns: (array)  The strings stripped of ANSI color escape sequences
+#          (scalar) The same, concatenated
+sub colorstrip {
+    my (@string) = @_;
+    for my $string (@string) {
+        $string =~ s{ \e\[ [\d;]* m }{}xmsg;
+    }
+    return wantarray ? @string : join(q{}, @string);
+}
+
+# Given a list of color attributes (arguments for color, for instance), return
+# true if they're all valid or false if any of them are invalid.
+#
+# @codes - A list of color attributes, possibly space-separated
+#
+# Returns: True if all the attributes are valid, false otherwise.
+sub colorvalid {
+    my (@codes) = @_;
+    @codes = map { split(q{ }, lc) } @codes;
+    for my $code (@codes) {
+        next if defined($ATTRIBUTES{$code});
+        next if defined($ALIASES{$code});
+        if ($code =~ m{ \A (?: on_ )? r (\d+) g (\d+) b (\d+) \z }xms) {
+            next if ($1 <= 255 && $2 <= 255 && $3 <= 255);
+        }
+        return;
+    }
+    return 1;
+}
+
+##############################################################################
+# Module return value and documentation
+##############################################################################
+
+# Ensure we evaluate to true.
+1;
+__END__
+
+=head1 NAME
+
+Term::ANSIColor - Color screen output using ANSI escape sequences
+
+=for stopwords
+cyan colorize namespace runtime TMTOWTDI cmd.exe cmd.exe. 4nt.exe. 4nt.exe
+command.com NT ESC Delvare SSH OpenSSH aixterm ECMA-048 Fraktur overlining
+Zenin reimplemented Allbery PUSHCOLOR POPCOLOR LOCALCOLOR openmethods.com
+openmethods.com. grey ATTR urxvt mistyped prepending Bareword filehandle
+Cygwin Starsinic aterm rxvt CPAN RGB Solarized Whitespace alphanumerics
+undef CLICOLOR NNN GGG RRR
+
+=head1 SYNOPSIS
+
+    use Term::ANSIColor;
+    print color('bold blue');
+    print "This text is bold blue.\n";
+    print color('reset');
+    print "This text is normal.\n";
+    print colored("Yellow on magenta.", 'yellow on_magenta'), "\n";
+    print "This text is normal.\n";
+    print colored(['yellow on_magenta'], 'Yellow on magenta.', "\n");
+    print colored(['red on_bright_yellow'], 'Red on bright yellow.', "\n");
+    print colored(['bright_red on_black'], 'Bright red on black.', "\n");
+    print "\n";
+
+    # Map escape sequences back to color names.
+    use Term::ANSIColor 1.04 qw(uncolor);
+    my @names = uncolor('01;31');
+    print join(q{ }, @names), "\n";
+
+    # Strip all color escape sequences.
+    use Term::ANSIColor 2.01 qw(colorstrip);
+    print colorstrip("\e[1mThis is bold\e[0m"), "\n";
+
+    # Determine whether a color is valid.
+    use Term::ANSIColor 2.02 qw(colorvalid);
+    my $valid = colorvalid('blue bold', 'on_magenta');
+    print "Color string is ", $valid ? "valid\n" : "invalid\n";
+
+    # Create new aliases for colors.
+    use Term::ANSIColor 4.00 qw(coloralias);
+    coloralias('alert', 'red');
+    print "Alert is ", coloralias('alert'), "\n";
+    print colored("This is in red.", 'alert'), "\n";
+
+    use Term::ANSIColor qw(:constants);
+    print BOLD, BLUE, "This text is in bold blue.\n", RESET;
+
+    use Term::ANSIColor qw(:constants);
+    {
+        local $Term::ANSIColor::AUTORESET = 1;
+        print BOLD BLUE "This text is in bold blue.\n";
+        print "This text is normal.\n";
+    }
+
+    use Term::ANSIColor 2.00 qw(:pushpop);
+    print PUSHCOLOR RED ON_GREEN "This text is red on green.\n";
+    print PUSHCOLOR BRIGHT_BLUE "This text is bright blue on green.\n";
+    print RESET BRIGHT_BLUE "This text is just bright blue.\n";
+    print POPCOLOR "Back to red on green.\n";
+    print LOCALCOLOR GREEN ON_BLUE "This text is green on blue.\n";
+    print "This text is red on green.\n";
+    {
+        local $Term::ANSIColor::AUTOLOCAL = 1;
+        print ON_BLUE "This text is red on blue.\n";
+        print "This text is red on green.\n";
+    }
+    print POPCOLOR "Back to whatever we started as.\n";
+
+=head1 DESCRIPTION
+
+This module has two interfaces, one through color() and colored() and the
+other through constants.  It also offers the utility functions uncolor(),
+colorstrip(), colorvalid(), and coloralias(), which have to be explicitly
+imported to be used (see L</SYNOPSIS>).
+
+If you are using Term::ANSIColor in a console command, consider supporting the
+CLICOLOR standard.  See L</"Supporting CLICOLOR"> for more information.
+
+See L</COMPATIBILITY> for the versions of Term::ANSIColor that introduced
+particular features and the versions of Perl that included them.
+
+=head2 Supported Colors
+
+Terminal emulators that support color divide into four types: ones that
+support only eight colors, ones that support sixteen, ones that support 256,
+and ones that support 24-bit color.  This module provides the ANSI escape
+codes for all of them.  These colors are referred to as ANSI colors 0 through
+7 (normal), 8 through 15 (16-color), 16 through 255 (256-color), and true
+color (called direct-color by B<xterm>).
+
+Unfortunately, interpretation of colors 0 through 7 often depends on
+whether the emulator supports eight colors or sixteen colors.  Emulators
+that only support eight colors (such as the Linux console) will display
+colors 0 through 7 with normal brightness and ignore colors 8 through 15,
+treating them the same as white.  Emulators that support 16 colors, such
+as gnome-terminal, normally display colors 0 through 7 as dim or darker
+versions and colors 8 through 15 as normal brightness.  On such emulators,
+the "normal" white (color 7) usually is shown as pale grey, requiring
+bright white (15) to be used to get a real white color.  Bright black
+usually is a dark grey color, although some terminals display it as pure
+black.  Some sixteen-color terminal emulators also treat normal yellow
+(color 3) as orange or brown, and bright yellow (color 11) as yellow.
+
+Following the normal convention of sixteen-color emulators, this module
+provides a pair of attributes for each color.  For every normal color (0
+through 7), the corresponding bright color (8 through 15) is obtained by
+prepending the string C<bright_> to the normal color name.  For example,
+C<red> is color 1 and C<bright_red> is color 9.  The same applies for
+background colors: C<on_red> is the normal color and C<on_bright_red> is
+the bright color.  Capitalize these strings for the constant interface.
+
+There is unfortunately no way to know whether the current emulator
+supports more than eight colors, which makes the choice of colors
+difficult.  The most conservative choice is to use only the regular
+colors, which are at least displayed on all emulators.  However, they will
+appear dark in sixteen-color terminal emulators, including most common
+emulators in UNIX X environments.  If you know the display is one of those
+emulators, you may wish to use the bright variants instead.  Even better,
+offer the user a way to configure the colors for a given application to
+fit their terminal emulator.
+
+For 256-color emulators, this module additionally provides C<ansi0>
+through C<ansi15>, which are the same as colors 0 through 15 in
+sixteen-color emulators but use the 256-color escape syntax, C<grey0>
+through C<grey23> ranging from nearly black to nearly white, and a set of
+RGB colors.  The RGB colors are of the form C<rgbI<RGB>> where I<R>, I<G>,
+and I<B> are numbers from 0 to 5 giving the intensity of red, green, and
+blue.  The grey and RGB colors are also available as C<ansi16> through
+C<ansi255> if you want simple names for all 256 colors.  C<on_> variants
+of all of these colors are also provided.  These colors may be ignored
+completely on non-256-color terminals or may be misinterpreted and produce
+random behavior.  Additional attributes such as blink, italic, or bold may
+not work with the 256-color palette.
+
+For true color emulators, this module supports attributes of the form C<<
+rI<NNN>gI<NNN>bI<NNN> >> and C<< on_rI<NNN>gI<NNN>bI<NNN> >> for all values of
+I<NNN> between 0 and 255.  These represent foreground and background colors,
+respectively, with the RGB values given by the I<NNN> numbers.  These colors
+may be ignored completely on non-true-color terminals or may be misinterpreted
+and produce random behavior.
+
+=head2 Function Interface
+
+The function interface uses attribute strings to describe the colors and
+text attributes to assign to text.  The recognized non-color attributes
+are clear, reset, bold, dark, faint, italic, underline, underscore, blink,
+reverse, and concealed.  Clear and reset (reset to default attributes),
+dark and faint (dim and saturated), and underline and underscore are
+equivalent, so use whichever is the most intuitive to you.
+
+Note that not all attributes are supported by all terminal types, and some
+terminals may not support any of these sequences.  Dark and faint, italic,
+blink, and concealed in particular are frequently not implemented.
+
+The recognized normal foreground color attributes (colors 0 to 7) are:
+
+  black  red  green  yellow  blue  magenta  cyan  white
+
+The corresponding bright foreground color attributes (colors 8 to 15) are:
+
+  bright_black  bright_red      bright_green  bright_yellow
+  bright_blue   bright_magenta  bright_cyan   bright_white
+
+The recognized normal background color attributes (colors 0 to 7) are:
+
+  on_black  on_red      on_green  on yellow
+  on_blue   on_magenta  on_cyan   on_white
+
+The recognized bright background color attributes (colors 8 to 15) are:
+
+  on_bright_black  on_bright_red      on_bright_green  on_bright_yellow
+  on_bright_blue   on_bright_magenta  on_bright_cyan   on_bright_white
+
+For 256-color terminals, the recognized foreground colors are:
+
+  ansi0 .. ansi255
+  grey0 .. grey23
+
+plus C<rgbI<RGB>> for I<R>, I<G>, and I<B> values from 0 to 5, such as
+C<rgb000> or C<rgb515>.  Similarly, the recognized background colors are:
+
+  on_ansi0 .. on_ansi255
+  on_grey0 .. on_grey23
+
+plus C<on_rgbI<RGB>> for I<R>, I<G>, and I<B> values from 0 to 5.
+
+For true color terminals, the recognized foreground colors are C<<
+rI<RRR>gI<GGG>bI<BBB> >> for I<RRR>, I<GGG>, and I<BBB> values between 0 and
+255.  Similarly, the recognized background colors are C<<
+on_rI<RRR>gI<GGG>bI<BBB> >> for I<RRR>, I<GGG>, and I<BBB> values between 0
+and 255.
+
+For any of the above listed attributes, case is not significant.
+
+Attributes, once set, last until they are unset (by printing the attribute
+C<clear> or C<reset>).  Be careful to do this, or otherwise your attribute
+will last after your script is done running, and people get very annoyed
+at having their prompt and typing changed to weird colors.
+
+=over 4
+
+=item color(ATTR[, ATTR ...])
+
+color() takes any number of strings as arguments and considers them to be
+space-separated lists of attributes.  It then forms and returns the escape
+sequence to set those attributes.  It doesn't print it out, just returns
+it, so you'll have to print it yourself if you want to.  This is so that
+you can save it as a string, pass it to something else, send it to a file
+handle, or do anything else with it that you might care to.  color()
+throws an exception if given an invalid attribute.
+
+=item colored(STRING, ATTR[, ATTR ...])
+
+=item colored(ATTR-REF, STRING[, STRING...])
+
+As an aid in resetting colors, colored() takes a scalar as the first
+argument and any number of attribute strings as the second argument and
+returns the scalar wrapped in escape codes so that the attributes will be
+set as requested before the string and reset to normal after the string.
+Alternately, you can pass a reference to an array as the first argument,
+and then the contents of that array will be taken as attributes and color
+codes and the remainder of the arguments as text to colorize.
+
+Normally, colored() just puts attribute codes at the beginning and end of
+the string, but if you set $Term::ANSIColor::EACHLINE to some string, that
+string will be considered the line delimiter and the attribute will be set
+at the beginning of each line of the passed string and reset at the end of
+each line.  This is often desirable if the output contains newlines and
+you're using background colors, since a background color that persists
+across a newline is often interpreted by the terminal as providing the
+default background color for the next line.  Programs like pagers can also
+be confused by attributes that span lines.  Normally you'll want to set
+$Term::ANSIColor::EACHLINE to C<"\n"> to use this feature.
+
+Particularly consider setting $Term::ANSIColor::EACHLINE if you are
+interleaving output to standard output and standard error and you aren't
+flushing standard output (via autoflush() or setting C<$|>).  If you don't,
+the code to reset the color may unexpectedly sit in the standard output buffer
+rather than going to the display, causing standard error output to appear in
+the wrong color.
+
+=item uncolor(ESCAPE)
+
+uncolor() performs the opposite translation as color(), turning escape
+sequences into a list of strings corresponding to the attributes being set
+by those sequences.  uncolor() will never return C<ansi16> through
+C<ansi255>, instead preferring the C<grey> and C<rgb> names (and likewise
+for C<on_ansi16> through C<on_ansi255>).
+
+=item colorstrip(STRING[, STRING ...])
+
+colorstrip() removes all color escape sequences from the provided strings,
+returning the modified strings separately in array context or joined
+together in scalar context.  Its arguments are not modified.
+
+=item colorvalid(ATTR[, ATTR ...])
+
+colorvalid() takes attribute strings the same as color() and returns true
+if all attributes are known and false otherwise.
+
+=item coloralias(ALIAS[, ATTR ...])
+
+If ATTR is specified, it is interpreted as a list of space-separated strings
+naming attributes or existing aliases.  In this case, coloralias() sets up an
+alias of ALIAS for the set of attributes given by ATTR.  From that point
+forward, ALIAS can be passed into color(), colored(), and colorvalid() and
+will have the same meaning as the sequence of attributes given in ATTR.  One
+possible use of this facility is to give more meaningful names to the
+256-color RGB colors.  Only ASCII alphanumerics, C<.>, C<_>, and C<-> are
+allowed in alias names.
+
+If ATTR includes aliases, those aliases will be expanded at definition time
+and their values will be used to define the new alias.  This means that if you
+define an alias A in terms of another alias B, and then later redefine alias
+B, the value of alias A will not change.
+
+If ATTR is not specified, coloralias() returns the standard attribute or
+attributes to which ALIAS is aliased, if any, or undef if ALIAS does not
+exist.  If it is aliased to multiple attributes, the return value will be a
+single string and the attributes will be separated by spaces.
+
+This is the same facility used by the ANSI_COLORS_ALIASES environment
+variable (see L</ENVIRONMENT> below) but can be used at runtime, not just
+when the module is loaded.
+
+Later invocations of coloralias() with the same ALIAS will override
+earlier aliases.  There is no way to remove an alias.
+
+Aliases have no effect on the return value of uncolor().
+
+B<WARNING>: Aliases are global and affect all callers in the same process.
+There is no way to set an alias limited to a particular block of code or a
+particular object.
+
+=back
+
+=head2 Constant Interface
+
+Alternately, if you import C<:constants>, you can use the following
+constants directly:
+
+  CLEAR           RESET             BOLD            DARK
+  FAINT           ITALIC            UNDERLINE       UNDERSCORE
+  BLINK           REVERSE           CONCEALED
+
+  BLACK           RED               GREEN           YELLOW
+  BLUE            MAGENTA           CYAN            WHITE
+  BRIGHT_BLACK    BRIGHT_RED        BRIGHT_GREEN    BRIGHT_YELLOW
+  BRIGHT_BLUE     BRIGHT_MAGENTA    BRIGHT_CYAN     BRIGHT_WHITE
+
+  ON_BLACK        ON_RED            ON_GREEN        ON_YELLOW
+  ON_BLUE         ON_MAGENTA        ON_CYAN         ON_WHITE
+  ON_BRIGHT_BLACK ON_BRIGHT_RED     ON_BRIGHT_GREEN ON_BRIGHT_YELLOW
+  ON_BRIGHT_BLUE  ON_BRIGHT_MAGENTA ON_BRIGHT_CYAN  ON_BRIGHT_WHITE
+
+These are the same as color('attribute') and can be used if you prefer
+typing:
+
+    print BOLD BLUE ON_WHITE "Text", RESET, "\n";
+
+to
+
+    print colored ("Text", 'bold blue on_white'), "\n";
+
+(Note that the newline is kept separate to avoid confusing the terminal as
+described above since a background color is being used.)
+
+If you import C<:constants256>, you can use the following constants
+directly:
+
+  ANSI0 .. ANSI255
+  GREY0 .. GREY23
+
+  RGBXYZ (for X, Y, and Z values from 0 to 5, like RGB000 or RGB515)
+
+  ON_ANSI0 .. ON_ANSI255
+  ON_GREY0 .. ON_GREY23
+
+  ON_RGBXYZ (for X, Y, and Z values from 0 to 5)
+
+Note that C<:constants256> does not include the other constants, so if you
+want to mix both, you need to include C<:constants> as well.  You may want
+to explicitly import at least C<RESET>, as in:
+
+    use Term::ANSIColor 4.00 qw(RESET :constants256);
+
+True color and aliases are not supported by the constant interface.
+
+When using the constants, if you don't want to have to remember to add the
+C<, RESET> at the end of each print line, you can set
+$Term::ANSIColor::AUTORESET to a true value.  Then, the display mode will
+automatically be reset if there is no comma after the constant.  In other
+words, with that variable set:
+
+    print BOLD BLUE "Text\n";
+
+will reset the display mode afterward, whereas:
+
+    print BOLD, BLUE, "Text\n";
+
+will not.  If you are using background colors, you will probably want to
+either use say() (in newer versions of Perl) or print the newline with a
+separate print statement to avoid confusing the terminal.
+
+If $Term::ANSIColor::AUTOLOCAL is set (see below), it takes precedence
+over $Term::ANSIColor::AUTORESET, and the latter is ignored.
+
+The subroutine interface has the advantage over the constants interface in
+that only two subroutines are exported into your namespace, versus
+thirty-eight in the constants interface, and aliases and true color attributes
+are supported.  On the flip side, the constants interface has the advantage of
+better compile time error checking, since misspelled names of colors or
+attributes in calls to color() and colored() won't be caught until runtime
+whereas misspelled names of constants will be caught at compile time.  So,
+pollute your namespace with almost two dozen subroutines that you may not even
+use that often, or risk a silly bug by mistyping an attribute.  Your choice,
+TMTOWTDI after all.
+
+=head2 The Color Stack
+
+You can import C<:pushpop> and maintain a stack of colors using PUSHCOLOR,
+POPCOLOR, and LOCALCOLOR.  PUSHCOLOR takes the attribute string that
+starts its argument and pushes it onto a stack of attributes.  POPCOLOR
+removes the top of the stack and restores the previous attributes set by
+the argument of a prior PUSHCOLOR.  LOCALCOLOR surrounds its argument in a
+PUSHCOLOR and POPCOLOR so that the color resets afterward.
+
+If $Term::ANSIColor::AUTOLOCAL is set, each sequence of color constants
+will be implicitly preceded by LOCALCOLOR.  In other words, the following:
+
+    {
+        local $Term::ANSIColor::AUTOLOCAL = 1;
+        print BLUE "Text\n";
+    }
+
+is equivalent to:
+
+    print LOCALCOLOR BLUE "Text\n";
+
+If $Term::ANSIColor::AUTOLOCAL is set, it takes precedence over
+$Term::ANSIColor::AUTORESET, and the latter is ignored.
+
+When using PUSHCOLOR, POPCOLOR, and LOCALCOLOR, it's particularly
+important to not put commas between the constants.
+
+    print PUSHCOLOR BLUE "Text\n";
+
+will correctly push BLUE onto the top of the stack.
+
+    print PUSHCOLOR, BLUE, "Text\n";    # wrong!
+
+will not, and a subsequent pop won't restore the correct attributes.
+PUSHCOLOR pushes the attributes set by its argument, which is normally a
+string of color constants.  It can't ask the terminal what the current
+attributes are.
+
+=head2 Supporting CLICOLOR
+
+L<https://bixense.com/clicolors/> proposes a standard for enabling and
+disabling color output from console commands using two environment variables,
+CLICOLOR and CLICOLOR_FORCE.  Term::ANSIColor cannot automatically support
+this standard, since the correct action depends on where the output is going
+and Term::ANSIColor may be used in a context where colors should always be
+generated even if CLICOLOR is set in the environment.  But you can use the
+supported environment variable ANSI_COLORS_DISABLED to implement CLICOLOR in
+your own programs with code like this:
+
+    if (exists($ENV{CLICOLOR}) && $ENV{CLICOLOR} == 0) {
+        if (!$ENV{CLICOLOR_FORCE}) {
+            $ENV{ANSI_COLORS_DISABLED} = 1;
+        }
+    }
+
+If you are using the constant interface, be sure to include this code before
+you use any color constants (such as at the very top of your script), since
+this environment variable is only honored the first time a color constant is
+seen.
+
+Be aware that this will export ANSI_COLORS_DISABLED to any child processes of
+your program as well.
+
+=head1 DIAGNOSTICS
+
+=over 4
+
+=item Bad color mapping %s
+
+(W) The specified color mapping from ANSI_COLORS_ALIASES is not valid and
+could not be parsed.  It was ignored.
+
+=item Bad escape sequence %s
+
+(F) You passed an invalid ANSI escape sequence to uncolor().
+
+=item Bareword "%s" not allowed while "strict subs" in use
+
+(F) You probably mistyped a constant color name such as:
+
+    $Foobar = FOOBAR . "This line should be blue\n";
+
+or:
+
+    @Foobar = FOOBAR, "This line should be blue\n";
+
+This will only show up under use strict (another good reason to run under
+use strict).
+
+=item Cannot alias standard color %s
+
+(F) The alias name passed to coloralias() matches a standard color name.
+Standard color names cannot be aliased.
+
+=item Cannot alias standard color %s in %s
+
+(W) The same, but in ANSI_COLORS_ALIASES.  The color mapping was ignored.
+
+=item Invalid alias name %s
+
+(F) You passed an invalid alias name to coloralias().  Alias names must
+consist only of alphanumerics, C<.>, C<->, and C<_>.
+
+=item Invalid alias name %s in %s
+
+(W) You specified an invalid alias name on the left hand of the equal sign
+in a color mapping in ANSI_COLORS_ALIASES.  The color mapping was ignored.
+
+=item Invalid attribute name %s
+
+(F) You passed an invalid attribute name to color(), colored(), or
+coloralias().
+
+=item Invalid attribute name %s in %s
+
+(W) You specified an invalid attribute name on the right hand of the equal
+sign in a color mapping in ANSI_COLORS_ALIASES.  The color mapping was
+ignored.
+
+=item Name "%s" used only once: possible typo
+
+(W) You probably mistyped a constant color name such as:
+
+    print FOOBAR "This text is color FOOBAR\n";
+
+It's probably better to always use commas after constant names in order to
+force the next error.
+
+=item No comma allowed after filehandle
+
+(F) You probably mistyped a constant color name such as:
+
+    print FOOBAR, "This text is color FOOBAR\n";
+
+Generating this fatal compile error is one of the main advantages of using
+the constants interface, since you'll immediately know if you mistype a
+color name.
+
+=item No name for escape sequence %s
+
+(F) The ANSI escape sequence passed to uncolor() contains escapes which
+aren't recognized and can't be translated to names.
+
+=back
+
+=head1 ENVIRONMENT
+
+=over 4
+
+=item ANSI_COLORS_ALIASES
+
+This environment variable allows the user to specify custom color aliases
+that will be understood by color(), colored(), and colorvalid().  None of
+the other functions will be affected, and no new color constants will be
+created.  The custom colors are aliases for existing color names; no new
+escape sequences can be introduced.  Only alphanumerics, C<.>, C<_>, and
+C<-> are allowed in alias names.
+
+The format is:
+
+    ANSI_COLORS_ALIASES='newcolor1=oldcolor1,newcolor2=oldcolor2'
+
+Whitespace is ignored.  The alias value can be a single attribute or a
+space-separated list of attributes.
+
+For example the L<Solarized|https://ethanschoonover.com/solarized> colors
+can be mapped with:
+
+    ANSI_COLORS_ALIASES='\
+        base00=bright_yellow, on_base00=on_bright_yellow,\
+        base01=bright_green,  on_base01=on_bright_green, \
+        base02=black,         on_base02=on_black,        \
+        base03=bright_black,  on_base03=on_bright_black, \
+        base0=bright_blue,    on_base0=on_bright_blue,   \
+        base1=bright_cyan,    on_base1=on_bright_cyan,   \
+        base2=white,          on_base2=on_white,         \
+        base3=bright_white,   on_base3=on_bright_white,  \
+        orange=bright_red,    on_orange=on_bright_red,   \
+        violet=bright_magenta,on_violet=on_bright_magenta'
+
+This environment variable is read and applied when the Term::ANSIColor
+module is loaded and is then subsequently ignored.  Changes to
+ANSI_COLORS_ALIASES after the module is loaded will have no effect.  See
+coloralias() for an equivalent facility that can be used at runtime.
+
+=item ANSI_COLORS_DISABLED
+
+If this environment variable is set to a true value, all of the functions
+defined by this module (color(), colored(), and all of the constants) will not
+output any escape sequences and instead will just return the empty string or
+pass through the original text as appropriate.  This is intended to support
+easy use of scripts using this module on platforms that don't support ANSI
+escape sequences.
+
+=item NO_COLOR
+
+If this environment variable is set to any value, it suppresses generation of
+escape sequences the same as if ANSI_COLORS_DISABLED is set to a true value.
+This implements the L<https://no-color.org/> informal standard.  Programs that
+want to enable color despite NO_COLOR being set will need to unset that
+environment variable before any constant or function provided by this module
+is used.
+
+=back
+
+=head1 COMPATIBILITY
+
+Term::ANSIColor was first included with Perl in Perl 5.6.0.
+
+The uncolor() function and support for ANSI_COLORS_DISABLED were added in
+Term::ANSIColor 1.04, included in Perl 5.8.0.
+
+Support for dark was added in Term::ANSIColor 1.08, included in Perl
+5.8.4.
+
+The color stack, including the C<:pushpop> import tag, PUSHCOLOR,
+POPCOLOR, LOCALCOLOR, and the $Term::ANSIColor::AUTOLOCAL variable, was
+added in Term::ANSIColor 2.00, included in Perl 5.10.1.
+
+colorstrip() was added in Term::ANSIColor 2.01 and colorvalid() was added
+in Term::ANSIColor 2.02, both included in Perl 5.11.0.
+
+Support for colors 8 through 15 (the C<bright_> variants) was added in
+Term::ANSIColor 3.00, included in Perl 5.13.3.
+
+Support for italic was added in Term::ANSIColor 3.02, included in Perl
+5.17.1.
+
+Support for colors 16 through 256 (the C<ansi>, C<rgb>, and C<grey>
+colors), the C<:constants256> import tag, the coloralias() function, and
+support for the ANSI_COLORS_ALIASES environment variable were added in
+Term::ANSIColor 4.00, included in Perl 5.17.8.
+
+$Term::ANSIColor::AUTOLOCAL was changed to take precedence over
+$Term::ANSIColor::AUTORESET, rather than the other way around, in
+Term::ANSIColor 4.00, included in Perl 5.17.8.
+
+C<ansi16> through C<ansi255>, as aliases for the C<rgb> and C<grey> colors,
+and the corresponding C<on_ansi> names and C<ANSI> and C<ON_ANSI> constants
+were added in Term::ANSIColor 4.06, included in Perl 5.25.7.
+
+Support for true color (the C<rNNNgNNNbNNN> and C<on_rNNNgNNNbNNN>
+attributes), defining aliases in terms of other aliases, and aliases mapping
+to multiple attributes instead of only a single attribute was added in
+Term::ANSIColor 5.00.
+
+Support for NO_COLOR was added in Term::ANSIColor 5.01.
+
+=head1 RESTRICTIONS
+
+Both colored() and many uses of the color constants will add the reset escape
+sequence after a newline.  If a program mixes colored output to standard
+output with output to standard error, this can result in the standard error
+text having the wrong color because the reset escape sequence hasn't yet been
+flushed to the display (since standard output to a terminal is line-buffered
+by default).  To avoid this, either set autoflush() on STDOUT or set
+$Term::ANSIColor::EACHLINE to C<"\n">.
+
+It would be nice if one could leave off the commas around the constants
+entirely and just say:
+
+    print BOLD BLUE ON_WHITE "Text\n" RESET;
+
+but the syntax of Perl doesn't allow this.  You need a comma after the
+string.  (Of course, you may consider it a bug that commas between all the
+constants aren't required, in which case you may feel free to insert
+commas unless you're using $Term::ANSIColor::AUTORESET or
+PUSHCOLOR/POPCOLOR.)
+
+For easier debugging, you may prefer to always use the commas when not
+setting $Term::ANSIColor::AUTORESET or PUSHCOLOR/POPCOLOR so that you'll
+get a fatal compile error rather than a warning.
+
+It's not possible to use this module to embed formatting and color
+attributes using Perl formats.  They replace the escape character with a
+space (as documented in L<perlform(1)>), resulting in garbled output from
+the unrecognized attribute.  Even if there were a way around that problem,
+the format doesn't know that the non-printing escape sequence is
+zero-length and would incorrectly format the output.  For formatted output
+using color or other attributes, either use sprintf() instead or use
+formline() and then add the color or other attributes after formatting and
+before output.
+
+=head1 NOTES
+
+The codes generated by this module are standard terminal control codes,
+complying with ECMA-048 and ISO 6429 (generally referred to as "ANSI
+color" for the color codes).  The non-color control codes (bold, dark,
+italic, underline, and reverse) are part of the earlier ANSI X3.64
+standard for control sequences for video terminals and peripherals.
+
+Note that not all displays are ISO 6429-compliant, or even X3.64-compliant
+(or are even attempting to be so).  This module will not work as expected
+on displays that do not honor these escape sequences, such as cmd.exe,
+4nt.exe, and command.com under either Windows NT or Windows 2000.  They
+may just be ignored, or they may display as an ESC character followed by
+some apparent garbage.
+
+Jean Delvare provided the following table of different common terminal
+emulators and their support for the various attributes and others have
+helped me flesh it out:
+
+              clear    bold     faint   under    blink   reverse  conceal
+ ------------------------------------------------------------------------
+ xterm         yes      yes      no      yes      yes      yes      yes
+ linux         yes      yes      yes    bold      yes      yes      no
+ rxvt          yes      yes      no      yes  bold/black   yes      no
+ dtterm        yes      yes      yes     yes    reverse    yes      yes
+ teraterm      yes    reverse    no      yes    rev/red    yes      no
+ aixterm      kinda   normal     no      yes      no       yes      yes
+ PuTTY         yes     color     no      yes      no       yes      no
+ Windows       yes      no       no      no       no       yes      no
+ Cygwin SSH    yes      yes      no     color    color    color     yes
+ Terminal.app  yes      yes      no      yes      yes      yes      yes
+
+Windows is Windows telnet, Cygwin SSH is the OpenSSH implementation under
+Cygwin on Windows NT, and Mac Terminal is the Terminal application in Mac
+OS X.  Where the entry is other than yes or no, that emulator displays the
+given attribute as something else instead.  Note that on an aixterm, clear
+doesn't reset colors; you have to explicitly set the colors back to what
+you want.  More entries in this table are welcome.
+
+Support for code 3 (italic) is rare and therefore not mentioned in that
+table.  It is not believed to be fully supported by any of the terminals
+listed, although it's displayed as green in the Linux console, but it is
+reportedly supported by urxvt.
+
+Note that codes 6 (rapid blink) and 9 (strike-through) are specified in ANSI
+X3.64 and ECMA-048 but are not commonly supported by most displays and
+emulators and therefore aren't supported by this module.  ECMA-048 also
+specifies a large number of other attributes, including a sequence of
+attributes for font changes, Fraktur characters, double-underlining, framing,
+circling, and overlining.  As none of these attributes are widely supported or
+useful, they also aren't currently supported by this module.
+
+Most modern X terminal emulators support 256 colors.  Known to not support
+those colors are aterm, rxvt, Terminal.app, and TTY/VC.
+
+For information on true color support in various terminal emulators, see
+L<True Colour support|https://gist.github.com/XVilka/8346728>.
+
+=head1 AUTHORS
+
+Original idea (using constants) by Zenin, reimplemented using subs by Russ
+Allbery <rra@cpan.org>, and then combined with the original idea by
+Russ with input from Zenin.  256-color support is based on work by Kurt
+Starsinic.  Russ Allbery now maintains this module.
+
+PUSHCOLOR, POPCOLOR, and LOCALCOLOR were contributed by openmethods.com
+voice solutions.
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 1996-1998, 2000-2002, 2005-2006, 2008-2018, 2020 Russ Allbery
+<rra@cpan.org>
+
+Copyright 1996 Zenin
+
+Copyright 2012 Kurt Starsinic <kstarsinic@gmail.com>
+
+This program is free software; you may redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 SEE ALSO
+
+The CPAN module L<Term::ExtendedColor> provides a different and more
+comprehensive interface for 256-color emulators that may be more
+convenient.  The CPAN module L<Win32::Console::ANSI> provides ANSI color
+(and other escape sequence) support in the Win32 Console environment.
+The CPAN module L<Term::Chrome> provides a different interface using
+objects and operator overloading.
+
+ECMA-048 is available on-line (at least at the time of this writing) at
+L<https://www.ecma-international.org/publications/standards/Ecma-048.htm>.
+
+ISO 6429 is available from ISO for a charge; the author of this module
+does not own a copy of it.  Since the source material for ISO 6429 was
+ECMA-048 and the latter is available for free, there seems little reason
+to obtain the ISO standard.
+
+The 256-color control sequences are documented at
+L<https://invisible-island.net/xterm/ctlseqs/ctlseqs.html> (search for
+256-color).
+
+Information about true color support in various terminal emulators and test
+programs you can run to check the true color support in your terminal emulator
+are available at L<https://gist.github.com/XVilka/8346728>.
+
+L<CLICOLORS|https://bixense.com/clicolors/> and
+L<NO_COLOR|https://no-color.org/> are useful standards to be aware of, and
+ideally follow, for any application using color.  Term::ANSIColor complies
+with the latter.
+
+The current version of this module is always available from its web site
+at L<https://www.eyrie.org/~eagle/software/ansicolor/>.  It is also part
+of the Perl core distribution as of 5.6.0.
+
+=cut
+
+# Local Variables:
+# copyright-at-end-flag: t
+# End:

git/usr/share/perl5/core_perl/Term/Cap.pm

@@ -0,0 +1,772 @@
+package Term::Cap;
+
+# Since the debugger uses Term::ReadLine which uses Term::Cap, we want
+# to load as few modules as possible.  This includes Carp.pm.
+sub carp
+{
+    require Carp;
+    goto &Carp::carp;
+}
+
+sub croak
+{
+    require Carp;
+    goto &Carp::croak;
+}
+
+use strict;
+
+use vars qw($VERSION $VMS_TERMCAP);
+use vars qw($termpat $state $first $entry);
+
+$VERSION = '1.18';
+
+# TODO:
+# support Berkeley DB termcaps
+# force $FH into callers package?
+# keep $FH in object at Tgetent time?
+
+=head1 NAME
+
+Term::Cap - Perl termcap interface
+
+=head1 SYNOPSIS
+
+    require Term::Cap;
+    $terminal = Term::Cap->Tgetent({ TERM => undef, OSPEED => $ospeed });
+    $terminal->Trequire(qw/ce ku kd/);
+    $terminal->Tgoto('cm', $col, $row, $FH);
+    $terminal->Tputs('dl', $count, $FH);
+    $terminal->Tpad($string, $count, $FH);
+
+=head1 DESCRIPTION
+
+These are low-level functions to extract and use capabilities from
+a terminal capability (termcap) database.
+
+More information on the terminal capabilities will be found in the
+termcap manpage on most Unix-like systems.
+
+=head2 METHODS
+
+The output strings for B<Tputs> are cached for counts of 1 for performance.
+B<Tgoto> and B<Tpad> do not cache.  C<$self-E<gt>{_xx}> is the raw termcap
+data and C<$self-E<gt>{xx}> is the cached version.
+
+    print $terminal->Tpad($self->{_xx}, 1);
+
+B<Tgoto>, B<Tputs>, and B<Tpad> return the string and will also
+output the string to $FH if specified.
+
+
+=cut
+
+# Preload the default VMS termcap.
+# If a different termcap is required then the text of one can be supplied
+# in $Term::Cap::VMS_TERMCAP before Tgetent is called.
+
+if ( $^O eq 'VMS' )
+{
+    chomp( my @entry = <DATA> );
+    $VMS_TERMCAP = join '', @entry;
+}
+
+# Returns a list of termcap files to check.
+
+sub termcap_path
+{    ## private
+    my @termcap_path;
+
+    # $TERMCAP, if it's a filespec
+    push( @termcap_path, $ENV{TERMCAP} )
+      if (
+        ( exists $ENV{TERMCAP} )
+        && (
+            ( $^O eq 'os2' || $^O eq 'MSWin32' || $^O eq 'dos' )
+            ? $ENV{TERMCAP} =~ /^[a-z]:[\\\/]/is
+            : $ENV{TERMCAP} =~ /^\//s
+        )
+      );
+    if ( ( exists $ENV{TERMPATH} ) && ( $ENV{TERMPATH} ) )
+    {
+
+        # Add the users $TERMPATH
+        push( @termcap_path, split( /:|\s+/, $ENV{TERMPATH} ) );
+    }
+    else
+    {
+
+        # Defaults
+        push( @termcap_path,
+            exists $ENV{'HOME'} ? $ENV{'HOME'} . '/.termcap' : undef,
+            '/etc/termcap', '/usr/share/misc/termcap', );
+    }
+
+    # return the list of those termcaps that exist
+    return grep { defined $_ && -f $_ } @termcap_path;
+}
+
+=over 4
+
+=item B<Tgetent>
+
+Returns a blessed object reference which the user can
+then use to send the control strings to the terminal using B<Tputs>
+and B<Tgoto>.
+
+The function extracts the entry of the specified terminal
+type I<TERM> (defaults to the environment variable I<TERM>) from the
+database.
+
+It will look in the environment for a I<TERMCAP> variable.  If
+found, and the value does not begin with a slash, and the terminal
+type name is the same as the environment string I<TERM>, the
+I<TERMCAP> string is used instead of reading a termcap file.  If
+it does begin with a slash, the string is used as a path name of
+the termcap file to search.  If I<TERMCAP> does not begin with a
+slash and name is different from I<TERM>, B<Tgetent> searches the
+files F<$HOME/.termcap>, F</etc/termcap>, and F</usr/share/misc/termcap>,
+in that order, unless the environment variable I<TERMPATH> exists,
+in which case it specifies a list of file pathnames (separated by
+spaces or colons) to be searched B<instead>.  Whenever multiple
+files are searched and a tc field occurs in the requested entry,
+the entry it names must be found in the same file or one of the
+succeeding files.  If there is a C<:tc=...:> in the I<TERMCAP>
+environment variable string it will continue the search in the
+files as above.
+
+The extracted termcap entry is available in the object
+as C<$self-E<gt>{TERMCAP}>.
+
+It takes a hash reference as an argument with two optional keys:
+
+=over 2
+
+=item OSPEED
+
+The terminal output bit rate (often mistakenly called the baud rate)
+for this terminal - if not set a warning will be generated
+and it will be defaulted to 9600.  I<OSPEED> can be specified as
+either a POSIX termios/SYSV termio speeds (where 9600 equals 9600) or
+an old DSD-style speed ( where 13 equals 9600).
+
+
+=item TERM
+
+The terminal type whose termcap entry will be used - if not supplied it will
+default to $ENV{TERM}: if that is not set then B<Tgetent> will croak.
+
+=back
+
+It calls C<croak> on failure.
+
+=cut
+
+sub Tgetent
+{    ## public -- static method
+    my $class = shift;
+    my ($self) = @_;
+
+    $self = {} unless defined $self;
+    bless $self, $class;
+
+    my ( $term, $cap, $search, $field, $max, $tmp_term, $TERMCAP );
+    local ( $termpat, $state, $first, $entry );    # used inside eval
+    local $_;
+
+    # Compute PADDING factor from OSPEED (to be used by Tpad)
+    if ( !$self->{OSPEED} )
+    {
+        if ($^W)
+        {
+            carp "OSPEED was not set, defaulting to 9600";
+        }
+        $self->{OSPEED} = 9600;
+    }
+    if ( $self->{OSPEED} < 16 )
+    {
+
+        # delays for old style speeds
+        my @pad = (
+            0,    200, 133.3, 90.9, 74.3, 66.7, 50, 33.3,
+            16.7, 8.3, 5.5,   4.1,  2,    1,    .5, .2
+        );
+        $self->{PADDING} = $pad[ $self->{OSPEED} ];
+    }
+    else
+    {
+        $self->{PADDING} = 10000 / $self->{OSPEED};
+    }
+
+    unless ( $self->{TERM} )
+    {
+       if ( $ENV{TERM} )
+       {
+         $self->{TERM} =  $ENV{TERM} ;
+       }
+       else
+       {
+          if ( $^O eq 'MSWin32' )
+          {
+             $self->{TERM} =  'dumb';
+          }
+          else
+          {
+             croak "TERM not set";
+          }
+       }
+    }
+
+    $term = $self->{TERM};    # $term is the term type we are looking for
+
+    # $tmp_term is always the next term (possibly :tc=...:) we are looking for
+    $tmp_term = $self->{TERM};
+
+    # protect any pattern metacharacters in $tmp_term
+    $termpat = $tmp_term;
+    $termpat =~ s/(\W)/\\$1/g;
+
+    my $foo = ( exists $ENV{TERMCAP} ? $ENV{TERMCAP} : '' );
+
+    # $entry is the extracted termcap entry
+    if ( ( $foo !~ m:^/:s ) && ( $foo =~ m/(^|\|)${termpat}[:|]/s ) )
+    {
+        $entry = $foo;
+    }
+
+    my @termcap_path = termcap_path();
+
+    if ( !@termcap_path && !$entry )
+    {
+
+        # last resort--fake up a termcap from terminfo
+        local $ENV{TERM} = $term;
+
+        if ( $^O eq 'VMS' )
+        {
+            $entry = $VMS_TERMCAP;
+        }
+        else
+        {
+            if ( grep { -x "$_/infocmp" } split /:/, $ENV{PATH} )
+            {
+                eval {
+                    my $tmp = `infocmp -C 2>/dev/null`;
+                    $tmp =~ s/^#.*\n//gm;    # remove comments
+                    if (   ( $tmp !~ m%^/%s )
+                        && ( $tmp =~ /(^|\|)${termpat}[:|]/s ) )
+                    {
+                        $entry = $tmp;
+                    }
+                };
+                warn "Can't run infocmp to get a termcap entry: $@" if $@;
+            }
+            else
+            {
+               # this is getting desperate now
+               if ( $self->{TERM} eq 'dumb' )
+               {
+                  $entry = 'dumb|80-column dumb tty::am::co#80::bl=^G:cr=^M:do=^J:sf=^J:';
+               }
+            }
+        }
+    }
+
+    croak "Can't find a valid termcap file" unless @termcap_path || $entry;
+
+    $state = 1;    # 0 == finished
+                   # 1 == next file
+                   # 2 == search again
+
+    $first = 0;    # first entry (keeps term name)
+
+    $max = 32;     # max :tc=...:'s
+
+    if ($entry)
+    {
+
+        # ok, we're starting with $TERMCAP
+        $first++;    # we're the first entry
+                     # do we need to continue?
+        if ( $entry =~ s/:tc=([^:]+):/:/ )
+        {
+            $tmp_term = $1;
+
+            # protect any pattern metacharacters in $tmp_term
+            $termpat = $tmp_term;
+            $termpat =~ s/(\W)/\\$1/g;
+        }
+        else
+        {
+            $state = 0;    # we're already finished
+        }
+    }
+
+    # This is eval'ed inside the while loop for each file
+    $search = q{
+	while (<TERMCAP>) {
+	    next if /^\\t/ || /^#/;
+	    if ($_ =~ m/(^|\\|)${termpat}[:|]/o) {
+		chomp;
+		s/^[^:]*:// if $first++;
+		$state = 0;
+		while ($_ =~ s/\\\\$//) {
+		    defined(my $x = <TERMCAP>) or last;
+		    $_ .= $x; chomp;
+		}
+		last;
+	    }
+	}
+	defined $entry or $entry = '';
+	$entry .= $_ if $_;
+    };
+
+    while ( $state != 0 )
+    {
+        if ( $state == 1 )
+        {
+
+            # get the next TERMCAP
+            $TERMCAP = shift @termcap_path
+              || croak "failed termcap lookup on $tmp_term";
+        }
+        else
+        {
+
+            # do the same file again
+            # prevent endless recursion
+            $max-- || croak "failed termcap loop at $tmp_term";
+            $state = 1;    # ok, maybe do a new file next time
+        }
+
+        open( TERMCAP, "< $TERMCAP\0" ) || croak "open $TERMCAP: $!";
+        eval $search;
+        die $@ if $@;
+        close TERMCAP;
+
+        # If :tc=...: found then search this file again
+        $entry =~ s/:tc=([^:]+):/:/ && ( $tmp_term = $1, $state = 2 );
+
+        # protect any pattern metacharacters in $tmp_term
+        $termpat = $tmp_term;
+        $termpat =~ s/(\W)/\\$1/g;
+    }
+
+    croak "Can't find $term" if $entry eq '';
+    $entry =~ s/:+\s*:+/:/g;    # cleanup $entry
+    $entry =~ s/:+/:/g;         # cleanup $entry
+    $self->{TERMCAP} = $entry;  # save it
+                                # print STDERR "DEBUG: $entry = ", $entry, "\n";
+
+    # Precompile $entry into the object
+    $entry =~ s/^[^:]*://;
+    foreach $field ( split( /:[\s:\\]*/, $entry ) )
+    {
+        if ( defined $field && $field =~ /^(\w{2,})$/ )
+        {
+            $self->{ '_' . $field } = 1 unless defined $self->{ '_' . $1 };
+
+            # print STDERR "DEBUG: flag $1\n";
+        }
+        elsif ( defined $field && $field =~ /^(\w{2,})\@/ )
+        {
+            $self->{ '_' . $1 } = "";
+
+            # print STDERR "DEBUG: unset $1\n";
+        }
+        elsif ( defined $field && $field =~ /^(\w{2,})#(.*)/ )
+        {
+            $self->{ '_' . $1 } = $2 unless defined $self->{ '_' . $1 };
+
+            # print STDERR "DEBUG: numeric $1 = $2\n";
+        }
+        elsif ( defined $field && $field =~ /^(\w{2,})=(.*)/ )
+        {
+
+            # print STDERR "DEBUG: string $1 = $2\n";
+            next if defined $self->{ '_' . ( $cap = $1 ) };
+            $_ = $2;
+            if ( ord('A') == 193 )
+            {
+               s/\\E/\047/g;
+               s/\\(\d\d\d)/pack('c',oct($1) & 0177)/eg;
+               s/\\n/\n/g;
+               s/\\r/\r/g;
+               s/\\t/\t/g;
+               s/\\b/\b/g;
+               s/\\f/\f/g;
+               s/\\\^/\337/g;
+               s/\^\?/\007/g;
+               s/\^(.)/pack('c',ord($1) & 31)/eg;
+               s/\\(.)/$1/g;
+               s/\337/^/g;
+            }
+            else
+            {
+               s/\\E/\033/g;
+               s/\\(\d\d\d)/pack('c',oct($1) & 0177)/eg;
+               s/\\n/\n/g;
+               s/\\r/\r/g;
+               s/\\t/\t/g;
+               s/\\b/\b/g;
+               s/\\f/\f/g;
+               s/\\\^/\377/g;
+               s/\^\?/\177/g;
+               s/\^(.)/pack('c',ord($1) & 31)/eg;
+               s/\\(.)/$1/g;
+               s/\377/^/g;
+            }
+            $self->{ '_' . $cap } = $_;
+        }
+
+        # else { carp "junk in $term ignored: $field"; }
+    }
+    $self->{'_pc'} = "\0" unless defined $self->{'_pc'};
+    $self->{'_bc'} = "\b" unless defined $self->{'_bc'};
+    $self;
+}
+
+# $terminal->Tpad($string, $cnt, $FH);
+
+=item B<Tpad>
+
+Outputs a literal string with appropriate padding for the current terminal.
+
+It takes three arguments:
+
+=over 2
+
+=item B<$string>
+
+The literal string to be output.  If it starts with a number and an optional
+'*' then the padding will be increased by an amount relative to this number,
+if the '*' is present then this amount will be multiplied by $cnt.  This part
+of $string is removed before output/
+
+=item B<$cnt>
+
+Will be used to modify the padding applied to string as described above.
+
+=item B<$FH>
+
+An optional filehandle (or IO::Handle ) that output will be printed to.
+
+=back
+
+The padded $string is returned.
+
+=cut
+
+sub Tpad
+{    ## public
+    my $self = shift;
+    my ( $string, $cnt, $FH ) = @_;
+    my ( $decr, $ms );
+
+    if ( defined $string && $string =~ /(^[\d.]+)(\*?)(.*)$/ )
+    {
+        $ms = $1;
+        $ms *= $cnt if $2;
+        $string = $3;
+        $decr   = $self->{PADDING};
+        if ( $decr > .1 )
+        {
+            $ms += $decr / 2;
+            $string .= $self->{'_pc'} x ( $ms / $decr );
+        }
+    }
+    print $FH $string if $FH;
+    $string;
+}
+
+# $terminal->Tputs($cap, $cnt, $FH);
+
+=item B<Tputs>
+
+Output the string for the given capability padded as appropriate without
+any parameter substitution.
+
+It takes three arguments:
+
+=over 2
+
+=item B<$cap>
+
+The capability whose string is to be output.
+
+=item B<$cnt>
+
+A count passed to Tpad to modify the padding applied to the output string.
+If $cnt is zero or one then the resulting string will be cached.
+
+=item B<$FH>
+
+An optional filehandle (or IO::Handle ) that output will be printed to.
+
+=back
+
+The appropriate string for the capability will be returned.
+
+=cut
+
+sub Tputs
+{    ## public
+    my $self = shift;
+    my ( $cap, $cnt, $FH ) = @_;
+    my $string;
+
+    $cnt = 0 unless $cnt;
+
+    if ( $cnt > 1 )
+    {
+        $string = Tpad( $self, $self->{ '_' . $cap }, $cnt );
+    }
+    else
+    {
+
+        # cache result because Tpad can be slow
+        unless ( exists $self->{$cap} )
+        {
+            $self->{$cap} =
+              exists $self->{"_$cap"}
+              ? Tpad( $self, $self->{"_$cap"}, 1 )
+              : undef;
+        }
+        $string = $self->{$cap};
+    }
+    print $FH $string if $FH;
+    $string;
+}
+
+# $terminal->Tgoto($cap, $col, $row, $FH);
+
+=item B<Tgoto>
+
+B<Tgoto> decodes a cursor addressing string with the given parameters.
+
+There are four arguments:
+
+=over 2
+
+=item B<$cap>
+
+The name of the capability to be output.
+
+=item B<$col>
+
+The first value to be substituted in the output string ( usually the column
+in a cursor addressing capability )
+
+=item B<$row>
+
+The second value to be substituted in the output string (usually the row
+in cursor addressing capabilities)
+
+=item B<$FH>
+
+An optional filehandle (or IO::Handle ) to which the output string will be
+printed.
+
+=back
+
+Substitutions are made with $col and $row in the output string with the
+following sprintf() line formats:
+
+ %%   output `%'
+ %d   output value as in printf %d
+ %2   output value as in printf %2d
+ %3   output value as in printf %3d
+ %.   output value as in printf %c
+ %+x  add x to value, then do %.
+
+ %>xy if value > x then add y, no output
+ %r   reverse order of two parameters, no output
+ %i   increment by one, no output
+ %B   BCD (16*(value/10)) + (value%10), no output
+
+ %n   exclusive-or all parameters with 0140 (Datamedia 2500)
+ %D   Reverse coding (value - 2*(value%16)), no output (Delta Data)
+
+The output string will be returned.
+
+=cut
+
+sub Tgoto
+{    ## public
+    my $self = shift;
+    my ( $cap, $code, $tmp, $FH ) = @_;
+    my $string = $self->{ '_' . $cap };
+    my $result = '';
+    my $after  = '';
+    my $online = 0;
+    my @tmp    = ( $tmp, $code );
+    my $cnt    = $code;
+
+    while ( $string =~ /^([^%]*)%(.)(.*)/ )
+    {
+        $result .= $1;
+        $code   = $2;
+        $string = $3;
+        if ( $code eq 'd' )
+        {
+            $result .= sprintf( "%d", shift(@tmp) );
+        }
+        elsif ( $code eq '.' )
+        {
+            $tmp = shift(@tmp);
+            if ( $tmp == 0 || $tmp == 4 || $tmp == 10 )
+            {
+                if ($online)
+                {
+                    ++$tmp, $after .= $self->{'_up'} if $self->{'_up'};
+                }
+                else
+                {
+                    ++$tmp, $after .= $self->{'_bc'};
+                }
+            }
+            $result .= sprintf( "%c", $tmp );
+            $online = !$online;
+        }
+        elsif ( $code eq '+' )
+        {
+            $result .= sprintf( "%c", shift(@tmp) + ord($string) );
+            $string = substr( $string, 1, 99 );
+            $online = !$online;
+        }
+        elsif ( $code eq 'r' )
+        {
+            ( $code, $tmp ) = @tmp;
+            @tmp = ( $tmp, $code );
+            $online = !$online;
+        }
+        elsif ( $code eq '>' )
+        {
+            ( $code, $tmp, $string ) = unpack( "CCa99", $string );
+            if ( $tmp[0] > $code )
+            {
+                $tmp[0] += $tmp;
+            }
+        }
+        elsif ( $code eq '2' )
+        {
+            $result .= sprintf( "%02d", shift(@tmp) );
+            $online = !$online;
+        }
+        elsif ( $code eq '3' )
+        {
+            $result .= sprintf( "%03d", shift(@tmp) );
+            $online = !$online;
+        }
+        elsif ( $code eq 'i' )
+        {
+            ( $code, $tmp ) = @tmp;
+            @tmp = ( $code + 1, $tmp + 1 );
+        }
+        else
+        {
+            return "OOPS";
+        }
+    }
+    $string = Tpad( $self, $result . $string . $after, $cnt );
+    print $FH $string if $FH;
+    $string;
+}
+
+# $terminal->Trequire(qw/ce ku kd/);
+
+=item B<Trequire>
+
+Takes a list of capabilities as an argument and will croak if one is not
+found.
+
+=cut
+
+sub Trequire
+{    ## public
+    my $self = shift;
+    my ( $cap, @undefined );
+    foreach $cap (@_)
+    {
+        push( @undefined, $cap )
+          unless defined $self->{ '_' . $cap } && $self->{ '_' . $cap };
+    }
+    croak "Terminal does not support: (@undefined)" if @undefined;
+}
+
+=back
+
+=head1 EXAMPLES
+
+    use Term::Cap;
+
+    # Get terminal output speed
+    require POSIX;
+    my $termios = POSIX::Termios->new;
+    $termios->getattr;
+    my $ospeed = $termios->getospeed;
+
+    # Old-style ioctl code to get ospeed:
+    #     require 'ioctl.pl';
+    #     ioctl(TTY,$TIOCGETP,$sgtty);
+    #     ($ispeed,$ospeed) = unpack('cc',$sgtty);
+
+    # allocate and initialize a terminal structure
+    my $terminal = Term::Cap->Tgetent({ TERM => undef, OSPEED => $ospeed });
+
+    # require certain capabilities to be available
+    $terminal->Trequire(qw/ce ku kd/);
+
+    # Output Routines, if $FH is undefined these just return the string
+
+    # Tgoto does the % expansion stuff with the given args
+    $terminal->Tgoto('cm', $col, $row, $FH);
+
+    # Tputs doesn't do any % expansion.
+    $terminal->Tputs('dl', $count = 1, $FH);
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 1995-2015 (c) perl5 porters.
+
+This software is free software and can be modified and distributed under
+the same terms as Perl itself.
+
+Please see the file README in the Perl source distribution for details of
+the Perl license.
+
+=head1 AUTHOR
+
+This module is part of the core Perl distribution and is also maintained
+for CPAN by Jonathan Stowe <jns@gellyfish.co.uk>.
+
+The code is hosted on Github: https://github.com/jonathanstowe/Term-Cap
+please feel free to fork, submit patches etc, etc there.
+
+=head1 SEE ALSO
+
+termcap(5)
+
+=cut
+
+# Below is a default entry for systems where there are terminals but no
+# termcap
+1;
+__DATA__
+vt220|vt200|DEC VT220 in vt100 emulation mode:
+am:mi:xn:xo:
+co#80:li#24:
+RA=\E[?7l:SA=\E[?7h:
+ac=kkllmmjjnnwwqquuttvvxx:ae=\E(B:al=\E[L:as=\E(0:
+bl=^G:cd=\E[J:ce=\E[K:cl=\E[H\E[2J:cm=\E[%i%d;%dH:
+cr=^M:cs=\E[%i%d;%dr:dc=\E[P:dl=\E[M:do=\E[B:
+ei=\E[4l:ho=\E[H:im=\E[4h:
+is=\E[1;24r\E[24;1H:
+nd=\E[C:
+kd=\E[B::kl=\E[D:kr=\E[C:ku=\E[A:le=^H:
+mb=\E[5m:md=\E[1m:me=\E[m:mr=\E[7m:
+kb=\0177:
+r2=\E>\E[24;1H\E[?3l\E[?4l\E[?5l\E[?7h\E[?8h\E=:rc=\E8:
+sc=\E7:se=\E[27m:sf=\ED:so=\E[7m:sr=\EM:ta=^I:
+ue=\E[24m:up=\E[A:us=\E[4m:ve=\E[?25h:vi=\E[?25l:
+

git/usr/share/perl5/core_perl/Term/Complete.pm

@@ -0,0 +1,188 @@
+package Term::Complete;
+require 5.000;
+require Exporter;
+
+use strict;
+our @ISA = qw(Exporter);
+our @EXPORT = qw(Complete);
+our $VERSION = '1.403';
+
+#      @(#)complete.pl,v1.2            (me@anywhere.EBay.Sun.COM) 09/23/91
+
+=head1 NAME
+
+Term::Complete - Perl word completion module
+
+=head1 SYNOPSIS
+
+    $input = Complete('prompt_string', \@completion_list);
+    $input = Complete('prompt_string', @completion_list);
+
+=head1 DESCRIPTION
+
+This routine provides word completion on the list of words in
+the array (or array ref).
+
+The tty driver is put into raw mode and restored using an operating
+system specific command, in UNIX-like environments C<stty>.
+
+The following command characters are defined:
+
+=over 4
+
+=item E<lt>tabE<gt>
+
+Attempts word completion.
+Cannot be changed.
+
+=item ^D
+
+Prints completion list.
+Defined by I<$Term::Complete::complete>.
+
+=item ^U
+
+Erases the current input.
+Defined by I<$Term::Complete::kill>.
+
+=item E<lt>delE<gt>, E<lt>bsE<gt>
+
+Erases one character.
+Defined by I<$Term::Complete::erase1> and I<$Term::Complete::erase2>.
+
+=back
+
+=head1 DIAGNOSTICS
+
+Bell sounds when word completion fails.
+
+=head1 BUGS
+
+The completion character E<lt>tabE<gt> cannot be changed.
+
+=head1 AUTHOR
+
+Wayne Thompson
+
+=cut
+
+our($complete, $kill, $erase1, $erase2, $tty_raw_noecho, $tty_restore, $stty, $tty_safe_restore);
+our($tty_saved_state) = '';
+CONFIG: {
+    $complete = "\004";
+    $kill     = "\025";
+    $erase1 =   "\177";
+    $erase2 =   "\010";
+    foreach my $s (qw(/bin/stty /usr/bin/stty)) {
+	if (-x $s) {
+	    $tty_raw_noecho = "$s raw -echo";
+	    $tty_restore    = "$s -raw echo";
+	    $tty_safe_restore = $tty_restore;
+	    $stty = $s;
+	    last;
+	}
+    }
+}
+
+sub Complete {
+    my($prompt, @cmp_lst, $cmp, $test, $l, @match);
+    my ($return, $r) = ("", 0);
+
+    $return = "";
+    $r      = 0;
+
+    $prompt = shift;
+    if (ref $_[0] || $_[0] =~ /^\*/) {
+	@cmp_lst = sort @{$_[0]};
+    }
+    else {
+	@cmp_lst = sort(@_);
+    }
+
+    # Attempt to save the current stty state, to be restored later
+    if (defined $stty && defined $tty_saved_state && $tty_saved_state eq '') {
+	$tty_saved_state = qx($stty -g 2>/dev/null);
+	if ($?) {
+	    # stty -g not supported
+	    $tty_saved_state = undef;
+	}
+	else {
+	    $tty_saved_state =~ s/\s+$//g;
+	    $tty_restore = qq($stty "$tty_saved_state" 2>/dev/null);
+	}
+    }
+    system $tty_raw_noecho if defined $tty_raw_noecho;
+    LOOP: {
+        local $_;
+        print($prompt, $return);
+        while (($_ = getc(STDIN)) ne "\r") {
+            CASE: {
+                # (TAB) attempt completion
+                $_ eq "\t" && do {
+                    @match = grep(/^\Q$return/, @cmp_lst);
+                    unless ($#match < 0) {
+                        $l = length($test = shift(@match));
+                        foreach $cmp (@match) {
+                            until (substr($cmp, 0, $l) eq substr($test, 0, $l)) {
+                                $l--;
+                            }
+                        }
+                        print("\a");
+                        print($test = substr($test, $r, $l - $r));
+                        $r = length($return .= $test);
+                    }
+                    last CASE;
+                };
+
+                # (^D) completion list
+                $_ eq $complete && do {
+                    print(join("\r\n", '', grep(/^\Q$return/, @cmp_lst)), "\r\n");
+                    redo LOOP;
+                };
+
+                # (^U) kill
+                $_ eq $kill && do {
+                    if ($r) {
+                        $r	= 0;
+			$return	= "";
+                        print("\r\n");
+                        redo LOOP;
+                    }
+                    last CASE;
+                };
+
+                # (DEL) || (BS) erase
+                ($_ eq $erase1 || $_ eq $erase2) && do {
+                    if($r) {
+                        print("\b \b");
+                        chop($return);
+                        $r--;
+                    }
+                    last CASE;
+                };
+
+                # printable char
+                ord >= ord(" ") && do {
+                    $return .= $_;
+                    $r++;
+                    print;
+                    last CASE;
+                };
+            }
+        }
+    }
+
+    # system $tty_restore if defined $tty_restore;
+    if (defined $tty_saved_state && defined $tty_restore && defined $tty_safe_restore)
+    {
+	system $tty_restore;
+	if ($?) {
+	    # tty_restore caused error
+	    system $tty_safe_restore;
+	}
+    }
+    print("\n");
+    $return;
+}
+
+1;

git/usr/share/perl5/core_perl/Term/ReadLine.pm

@@ -0,0 +1,487 @@
+=head1 NAME
+
+Term::ReadLine - Perl interface to various C<readline> packages.
+If no real package is found, substitutes stubs instead of basic functions.
+
+=head1 SYNOPSIS
+
+  use Term::ReadLine;
+  my $term = Term::ReadLine->new('Simple Perl calc');
+  my $prompt = "Enter your arithmetic expression: ";
+  my $OUT = $term->OUT || \*STDOUT;
+  while ( defined ($_ = $term->readline($prompt)) ) {
+    my $res = eval($_);
+    warn $@ if $@;
+    print $OUT $res, "\n" unless $@;
+    $term->addhistory($_) if /\S/;
+  }
+
+=head1 DESCRIPTION
+
+This package is just a front end to some other packages. It's a stub to
+set up a common interface to the various ReadLine implementations found on
+CPAN (under the C<Term::ReadLine::*> namespace).
+
+=head1 Minimal set of supported functions
+
+All the supported functions should be called as methods, i.e., either as 
+
+  $term = Term::ReadLine->new('name');
+
+or as 
+
+  $term->addhistory('row');
+
+where $term is a return value of Term::ReadLine-E<gt>new().
+
+=over 12
+
+=item C<ReadLine>
+
+returns the actual package that executes the commands. Among possible
+values are C<Term::ReadLine::Gnu>, C<Term::ReadLine::Perl>,
+C<Term::ReadLine::Stub>.
+
+=item C<new>
+
+returns the handle for subsequent calls to following
+functions. Argument is the name of the application. Optionally can be
+followed by two arguments for C<IN> and C<OUT> filehandles. These
+arguments should be globs.
+
+=item C<readline>
+
+gets an input line, I<possibly> with actual C<readline>
+support. Trailing newline is removed. Returns C<undef> on C<EOF>.
+
+=item C<addhistory>
+
+adds the line to the history of input, from where it can be used if
+the actual C<readline> is present.
+
+=item C<IN>, C<OUT>
+
+return the filehandles for input and output or C<undef> if C<readline>
+input and output cannot be used for Perl.
+
+=item C<MinLine>
+
+If argument is specified, it is an advice on minimal size of line to
+be included into history.  C<undef> means do not include anything into
+history. Returns the old value.
+
+=item C<findConsole>
+
+returns an array with two strings that give most appropriate names for
+files for input and output using conventions C<"E<lt>$in">, C<"E<gt>out">.
+
+The strings returned may not be useful for 3-argument open().
+
+=item Attribs
+
+returns a reference to a hash which describes internal configuration
+of the package. Names of keys in this hash conform to standard
+conventions with the leading C<rl_> stripped.
+
+=item C<Features>
+
+Returns a reference to a hash with keys being features present in
+current implementation. Several optional features are used in the
+minimal interface: C<appname> should be present if the first argument
+to C<new> is recognized, and C<minline> should be present if
+C<MinLine> method is not dummy.  C<autohistory> should be present if
+lines are put into history automatically (maybe subject to
+C<MinLine>), and C<addhistory> if C<addhistory> method is not dummy.
+
+If C<Features> method reports a feature C<attribs> as present, the
+method C<Attribs> is not dummy.
+
+=back
+
+=head1 Additional supported functions
+
+Actually C<Term::ReadLine> can use some other package, that will
+support a richer set of commands.
+
+All these commands are callable via method interface and have names
+which conform to standard conventions with the leading C<rl_> stripped.
+
+The stub package included with the perl distribution allows some
+additional methods: 
+
+=over 12
+
+=item C<tkRunning>
+
+makes Tk event loop run when waiting for user input (i.e., during
+C<readline> method).
+
+=item C<event_loop>
+
+Registers call-backs to wait for user input (i.e., during C<readline>
+method).  This supersedes tkRunning.
+
+The first call-back registered is the call back for waiting.  It is
+expected that the callback will call the current event loop until
+there is something waiting to get on the input filehandle.  The parameter
+passed in is the return value of the second call back.
+
+The second call-back registered is the call back for registration.  The
+input filehandle (often STDIN, but not necessarily) will be passed in.
+
+For example, with AnyEvent:
+
+  $term->event_loop(sub {
+    my $data = shift;
+    $data->[1] = AE::cv();
+    $data->[1]->recv();
+  }, sub {
+    my $fh = shift;
+    my $data = [];
+    $data->[0] = AE::io($fh, 0, sub { $data->[1]->send() });
+    $data;
+  });
+
+The second call-back is optional if the call back is registered prior to
+the call to $term-E<gt>readline.
+
+Deregistration is done in this case by calling event_loop with C<undef>
+as its parameter:
+
+    $term->event_loop(undef);
+
+This will cause the data array ref to be removed, allowing normal garbage
+collection to clean it up.  With AnyEvent, that will cause $data->[0] to
+be cleaned up, and AnyEvent will automatically cancel the watcher at that
+time.  If another loop requires more than that to clean up a file watcher,
+that will be up to the caller to handle.
+
+=item C<ornaments>
+
+makes the command line stand out by using termcap data.  The argument
+to C<ornaments> should be 0, 1, or a string of a form
+C<"aa,bb,cc,dd">.  Four components of this string should be names of
+I<terminal capacities>, first two will be issued to make the prompt
+standout, last two to make the input line standout.
+
+=item C<newTTY>
+
+takes two arguments which are input filehandle and output filehandle.
+Switches to use these filehandles.
+
+=back
+
+One can check whether the currently loaded ReadLine package supports
+these methods by checking for corresponding C<Features>.
+
+=head1 EXPORTS
+
+None
+
+=head1 ENVIRONMENT
+
+The environment variable C<PERL_RL> governs which ReadLine clone is
+loaded. If the value is false, a dummy interface is used. If the value
+is true, it should be tail of the name of the package to use, such as
+C<Perl> or C<Gnu>.  
+
+As a special case, if the value of this variable is space-separated,
+the tail might be used to disable the ornaments by setting the tail to
+be C<o=0> or C<ornaments=0>.  The head should be as described above, say
+
+If the variable is not set, or if the head of space-separated list is
+empty, the best available package is loaded.
+
+  export "PERL_RL=Perl o=0" # Use Perl ReadLine sans ornaments
+  export "PERL_RL= o=0"     # Use best available ReadLine sans ornaments
+
+(Note that processing of C<PERL_RL> for ornaments is in the discretion of the 
+particular used C<Term::ReadLine::*> package).
+
+=cut
+
+use strict;
+
+package Term::ReadLine::Stub;
+our @ISA = qw'Term::ReadLine::Tk Term::ReadLine::TermCap';
+
+$DB::emacs = $DB::emacs;	# To pacify -w
+our @rl_term_set;
+*rl_term_set = \@Term::ReadLine::TermCap::rl_term_set;
+
+sub PERL_UNICODE_STDIN () { 0x0001 }
+
+sub ReadLine {'Term::ReadLine::Stub'}
+sub readline {
+  my $self = shift;
+  my ($in,$out,$str) = @$self;
+  my $prompt = shift;
+  print $out $rl_term_set[0], $prompt, $rl_term_set[1], $rl_term_set[2]; 
+  $self->register_Tk 
+     if not $Term::ReadLine::registered and $Term::ReadLine::toloop;
+  #$str = scalar <$in>;
+  $str = $self->get_line;
+  utf8::upgrade($str)
+      if (${^UNICODE} & PERL_UNICODE_STDIN || defined ${^ENCODING}) &&
+         utf8::valid($str);
+  print $out $rl_term_set[3]; 
+  # bug in 5.000: chomping empty string creates length -1:
+  chomp $str if defined $str;
+  $str;
+}
+sub addhistory {}
+
+# used for testing purpose
+sub devtty { return '/dev/tty' }
+
+sub findConsole {
+    my $console;
+    my $consoleOUT;
+
+    my $devtty = devtty();
+
+    if ($^O ne 'MSWin32' and -e $devtty) {
+	$console = $devtty;
+    } elsif ($^O eq 'MSWin32' or $^O eq 'msys' or -e "con") {
+       $console = 'CONIN$';
+       $consoleOUT = 'CONOUT$';
+    } elsif ($^O eq 'VMS') {
+	$console = "sys\$command";
+    } elsif ($^O eq 'os2' && !$DB::emacs) {
+	$console = "/dev/con";
+    } else {
+	$console = undef;
+    }
+
+    $consoleOUT = $console unless defined $consoleOUT;
+    $console = "&STDIN" unless defined $console;
+    if ($console eq $devtty && !open(my $fh, "<", $console)) {
+      $console = "&STDIN";
+      undef($consoleOUT);
+    }
+    if (!defined $consoleOUT) {
+      $consoleOUT = defined fileno(STDERR) && $^O ne 'MSWin32' ? "&STDERR" : "&STDOUT";
+    }
+    ($console,$consoleOUT);
+}
+
+sub new {
+  die "method new called with wrong number of arguments" 
+    unless @_==2 or @_==4;
+  #local (*FIN, *FOUT);
+  my ($FIN, $FOUT, $ret);
+  if (@_==2) {
+    my($console, $consoleOUT) = $_[0]->findConsole;
+
+    # the Windows CONIN$ needs GENERIC_WRITE mode to allow
+    # a SetConsoleMode() if we end up using Term::ReadKey
+    open FIN, (( $^O eq 'MSWin32' && $console eq 'CONIN$' ) ? '+<' : '<' ), $console;
+    # RT #132008:  Still need 2-arg open here
+    open FOUT,">$consoleOUT";
+
+    #OUT->autoflush(1);		# Conflicts with debugger?
+    my $sel = select(FOUT);
+    $| = 1;				# for DB::OUT
+    select($sel);
+    $ret = bless [\*FIN, \*FOUT];
+  } else {			# Filehandles supplied
+    $FIN = $_[2]; $FOUT = $_[3];
+    #OUT->autoflush(1);		# Conflicts with debugger?
+    my $sel = select($FOUT);
+    $| = 1;				# for DB::OUT
+    select($sel);
+    $ret = bless [$FIN, $FOUT];
+  }
+  if ($ret->Features->{ornaments} 
+      and not ($ENV{PERL_RL} and $ENV{PERL_RL} =~ /\bo\w*=0/)) {
+    local $Term::ReadLine::termcap_nowarn = 1;
+    $ret->ornaments(1);
+  }
+  return $ret;
+}
+
+sub newTTY {
+  my ($self, $in, $out) = @_;
+  $self->[0] = $in;
+  $self->[1] = $out;
+  my $sel = select($out);
+  $| = 1;				# for DB::OUT
+  select($sel);
+}
+
+sub IN { shift->[0] }
+sub OUT { shift->[1] }
+sub MinLine { undef }
+sub Attribs { {} }
+
+my %features = (tkRunning => 1, ornaments => 1, 'newTTY' => 1);
+sub Features { \%features }
+
+#sub get_line {
+#  my $self = shift;
+#  my $in = $self->IN;
+#  local ($/) = "\n";
+#  return scalar <$in>;
+#}
+
+package Term::ReadLine;		# So late to allow the above code be defined?
+
+our $VERSION = '1.17';
+
+my ($which) = exists $ENV{PERL_RL} ? split /\s+/, $ENV{PERL_RL} : undef;
+if ($which) {
+  if ($which =~ /\bgnu\b/i){
+    eval "use Term::ReadLine::Gnu;";
+  } elsif ($which =~ /\bperl\b/i) {
+    eval "use Term::ReadLine::Perl;";
+  } elsif ($which =~ /^(Stub|TermCap|Tk)$/) {
+    # it is already in memory to avoid false exception as seen in:
+    # PERL_RL=Stub perl -e'$SIG{__DIE__} = sub { print @_ }; require Term::ReadLine'
+  } else {
+    eval "use Term::ReadLine::$which;";
+  }
+} elsif (defined $which and $which ne '') {	# Defined but false
+  # Do nothing fancy
+} else {
+  eval "use Term::ReadLine::Gnu; 1" or eval "use Term::ReadLine::EditLine; 1" or eval "use Term::ReadLine::Perl; 1";
+}
+
+#require FileHandle;
+
+# To make possible switch off RL in debugger: (Not needed, work done
+# in debugger).
+our @ISA;
+if (defined &Term::ReadLine::Gnu::readline) {
+  @ISA = qw(Term::ReadLine::Gnu Term::ReadLine::Stub);
+} elsif (defined &Term::ReadLine::EditLine::readline) {
+  @ISA = qw(Term::ReadLine::EditLine Term::ReadLine::Stub);
+} elsif (defined &Term::ReadLine::Perl::readline) {
+  @ISA = qw(Term::ReadLine::Perl Term::ReadLine::Stub);
+} elsif (defined $which && defined &{"Term::ReadLine::$which\::readline"}) {
+  @ISA = "Term::ReadLine::$which";
+} else {
+  @ISA = qw(Term::ReadLine::Stub);
+}
+
+package Term::ReadLine::TermCap;
+
+# Prompt-start, prompt-end, command-line-start, command-line-end
+#     -- zero-width beautifies to emit around prompt and the command line.
+our @rl_term_set = ("","","","");
+# string encoded:
+our $rl_term_set = ',,,';
+
+our $terminal;
+sub LoadTermCap {
+  return if defined $terminal;
+  
+  require Term::Cap;
+  $terminal = Tgetent Term::Cap ({OSPEED => 9600}); # Avoid warning.
+}
+
+sub ornaments {
+  shift;
+  return $rl_term_set unless @_;
+  $rl_term_set = shift;
+  $rl_term_set ||= ',,,';
+  $rl_term_set = 'us,ue,md,me' if $rl_term_set eq '1';
+  my @ts = split /,/, $rl_term_set, 4;
+  eval { LoadTermCap };
+  unless (defined $terminal) {
+    warn("Cannot find termcap: $@\n") unless $Term::ReadLine::termcap_nowarn;
+    $rl_term_set = ',,,';
+    return;
+  }
+  @rl_term_set = map {$_ ? $terminal->Tputs($_,1) || '' : ''} @ts;
+  return $rl_term_set;
+}
+
+
+package Term::ReadLine::Tk;
+
+# This package inserts a Tk->fileevent() before the diamond operator.
+# The Tk watcher dispatches Tk events until the filehandle returned by
+# the$term->IN() accessor becomes ready for reading.  It's assumed
+# that the diamond operator will return a line of input immediately at
+# that point.
+
+my ($giveup);
+
+# maybe in the future the Tk-specific aspects will be removed.
+sub Tk_loop{
+    if (ref $Term::ReadLine::toloop)
+    {
+        $Term::ReadLine::toloop->[0]->($Term::ReadLine::toloop->[2]);
+    }
+    else
+    {
+        Tk::DoOneEvent(0) until $giveup;
+        $giveup = 0;
+    }
+};
+
+sub register_Tk {
+    my $self = shift;
+    unless ($Term::ReadLine::registered++)
+    {
+        if (ref $Term::ReadLine::toloop)
+        {
+            $Term::ReadLine::toloop->[2] = $Term::ReadLine::toloop->[1]->($self->IN) if $Term::ReadLine::toloop->[1];
+        }
+        else
+        {
+            Tk->fileevent($self->IN,'readable',sub { $giveup = 1});
+        }
+    }
+};
+
+sub tkRunning {
+  $Term::ReadLine::toloop = $_[1] if @_ > 1;
+  $Term::ReadLine::toloop;
+}
+
+sub event_loop {
+    shift;
+
+    # T::RL::Gnu and T::RL::Perl check that this exists, if not,
+    # it doesn't call the loop.  Those modules will need to be
+    # fixed before this can be removed.
+    if (not defined &Tk::DoOneEvent)
+    {
+        *Tk::DoOneEvent = sub {
+            die "what?"; # this shouldn't be called.
+        }
+    }
+
+    # store the callback in toloop, again so that other modules will
+    # recognise it and call us for the loop.
+    $Term::ReadLine::toloop = [ @_ ] if @_ > 0; # 0 because we shifted off $self.
+    $Term::ReadLine::toloop;
+}
+
+sub PERL_UNICODE_STDIN () { 0x0001 }
+
+sub get_line {
+  my $self = shift;
+  my ($in,$out,$str) = @$self;
+
+  if ($Term::ReadLine::toloop) {
+    $self->register_Tk if not $Term::ReadLine::registered;
+    $self->Tk_loop;
+  }
+
+  local ($/) = "\n";
+  $str = <$in>;
+
+  utf8::upgrade($str)
+      if (${^UNICODE} & PERL_UNICODE_STDIN || defined ${^ENCODING}) &&
+         utf8::valid($str);
+  print $out $rl_term_set[3];
+  # bug in 5.000: chomping empty string creates length -1:
+  chomp $str if defined $str;
+
+  $str;
+}
+
+1;
+

git/usr/share/perl5/core_perl/overload/numbers.pm

@@ -0,0 +1,176 @@
+# -*- mode: Perl; buffer-read-only: t -*-
+#
+#    lib/overload/numbers.pm
+#
+#    Copyright (C) 2008 by Larry Wall and others
+#
+#    You may distribute under the terms of either the GNU General Public
+#    License or the Artistic License, as specified in the README file.
+#
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
+# This file is built by regen/overload.pl.
+# Any changes made here will be lost!
+
+package overload::numbers;
+
+our @names = qw#
+    ()
+    (${}
+    (@{}
+    (%{}
+    (*{}
+    (&{}
+    (++
+    (--
+    (bool
+    (0+
+    (""
+    (!
+    (=
+    (abs
+    (neg
+    (<>
+    (int
+    (<
+    (<=
+    (>
+    (>=
+    (==
+    (!=
+    (lt
+    (le
+    (gt
+    (ge
+    (eq
+    (ne
+    (nomethod
+    (+
+    (+=
+    (-
+    (-=
+    (*
+    (*=
+    (/
+    (/=
+    (%
+    (%=
+    (**
+    (**=
+    (<<
+    (<<=
+    (>>
+    (>>=
+    (&
+    (&=
+    (&.
+    (&.=
+    (|
+    (|=
+    (|.
+    (|.=
+    (^
+    (^=
+    (^.
+    (^.=
+    (<=>
+    (cmp
+    (~
+    (~.
+    (atan2
+    (cos
+    (sin
+    (exp
+    (log
+    (sqrt
+    (x
+    (x=
+    (.
+    (.=
+    (~~
+    (-X
+    (qr
+#;
+
+our @enums = qw#
+    fallback
+    to_sv
+    to_av
+    to_hv
+    to_gv
+    to_cv
+    inc
+    dec
+    bool_
+    numer
+    string
+    not
+    copy
+    abs
+    neg
+    iter
+    int
+    lt
+    le
+    gt
+    ge
+    eq
+    ne
+    slt
+    sle
+    sgt
+    sge
+    seq
+    sne
+    nomethod
+    add
+    add_ass
+    subtr
+    subtr_ass
+    mult
+    mult_ass
+    div
+    div_ass
+    modulo
+    modulo_ass
+    pow
+    pow_ass
+    lshift
+    lshift_ass
+    rshift
+    rshift_ass
+    band
+    band_ass
+    sband
+    sband_ass
+    bor
+    bor_ass
+    sbor
+    sbor_ass
+    bxor
+    bxor_ass
+    sbxor
+    sbxor_ass
+    ncmp
+    scmp
+    compl
+    scompl
+    atan2
+    cos
+    sin
+    exp
+    log
+    sqrt
+    repeat
+    repeat_ass
+    concat
+    concat_ass
+    smart
+    ftest
+    regexp
+#;
+
+{ my $i = 0; our %names = map { $_ => $i++ } @names }
+
+{ my $i = 0; our %enums = map { $_ => $i++ } @enums }
+
+# ex: set ro ft=perl:

git/usr/share/perl5/core_perl/source/encoding.pm

@@ -0,0 +1,71 @@
+package source::encoding;
+
+use v5.40;
+
+our $VERSION = '0.01';
+
+our $ascii_hint_bits = 0x00000010;
+
+sub import {
+    unimport();     # Get rid of any 'use utf8'
+    my (undef, $arg) = @_;
+    if ($arg eq 'utf8') {
+        require utf8;
+        utf8->import;
+        return;
+    }
+    elsif ($arg eq 'ascii') {
+        $^H |= $ascii_hint_bits;
+        return;
+    }
+
+    die "Bad argument for source::encoding: '$arg'";
+}
+
+sub unimport {
+    $^H &= ~$ascii_hint_bits;
+    utf8->unimport;
+}
+
+1;
+__END__
+
+=head1 NAME
+
+source::encoding -- Declare Perl source code encoding
+
+=head1 SYNOPSIS
+
+ use source::encoding 'ascii';
+ use source::encoding 'utf8';
+ no source::encoding;
+
+=head1 DESCRIPTION
+
+These days, Perl code either generally contains only ASCII characters with
+C<\x{}> and similar escapes to represent non-ASCII, or C<S<use utf8>> is used
+to indicate that the source code itself contains characters encoded as UTF-8.
+
+That means that a character in the source code not meeting these criteria is
+often a typographical error.  This pragma is used to tell Perl to raise an
+error when this happens.
+
+S<C<use source::encoding 'utf8'>> is a synonym for S<C<use utf8>>.  They may
+be used interchangeably.
+
+S<C<use source::encoding 'ascii'>> turns off any UTF-8 expectations, and
+raises a fatal error if any character within its scope in the input source
+code is not ASCII (or ASCII-equivalent on EBCDIC systems).
+
+S<C<no source::encoding>> turns off any UTF-8/ASCII expectations for the
+remainder of its scope.  The meaning of non-ASCII characters is then
+undefined.
+
+S<C<use source::encoding 'ascii'>> is automatically enabled within the
+lexical scope of a S<C<use v5.41.0>> or higher.
+
+=head1 SEE ALSO
+
+L<utf8>
+
+=cut