five/hbrtl/pgserver/register.go

// Copyright (c) 2026 Charles KWON OhJun (charleskwonohjun@gmail.com)
// All rights reserved.

package pgserver

import (
	"context"
	"fmt"
	"os"
	"strconv"

	"five/hbrt"
)

// init wires the PG-server entry points into the runtime as
// HB_FUNCs. Importing this package (e.g. via _ "five/hbrtl/pgserver"
// from hbrtl's bootstrap) is enough; PRG code then sees:
//
//	pg_server_start( nPort | cAddr [, cAuthMode ] )
//	                                   → starts server, blocks
//	                                     (call inside SPAWN to keep
//	                                     the calling thread free)
//	pg_server_stop()                   → closes the active server
//
// Embedded callers compose this with their own DBF setup:
//
//	#include "FiveSqlDef.ch"
//	PROCEDURE Main()
//	   USE customers SHARED
//	   USE orders SHARED NEW
//	   pg_server_start( 5432 )    /* blocks; psql can now connect */
//	   RETURN
func init() {
	hbrt.HB_FUNC("PG_SERVER_START", pgServerStart)
	hbrt.HB_FUNC("PG_SERVER_STOP", pgServerStop)
	hbrt.HB_FUNC("PG_ADD_ROLE", pgAddRole)
	hbrt.HB_FUNC("PG_REMOVE_ROLE", pgRemoveRole)
	hbrt.HB_FUNC("PG_TLS_LOAD", pgTLSLoad)
	hbrt.HB_FUNC("PG_TLS_SELF_SIGNED", pgTLSSelfSigned)
	hbrt.HB_FUNC("PG_ALLOW_IP", pgAllowIP)
	hbrt.HB_FUNC("PG_CLEAR_ALLOWLIST", pgClearAllowList)
}

// pgTLSLoad loads a PEM cert/key pair and installs the resulting
// TLS config on the next PG_SERVER_START. PRG signature:
//
//	pg_tls_load( cCertPath, cKeyPath ) -> .T. | cErr
func pgTLSLoad(ctx *hbrt.HBContext) {
	if ctx.PCount() < 2 || !ctx.IsChar(1) || !ctx.IsChar(2) {
		ctx.RetC("pg_tls_load: cert and key paths required")
		return
	}
	if err := LoadTLSFromFiles(ctx.ParC(1), ctx.ParC(2)); err != nil {
		ctx.RetC(err.Error())
		return
	}
	ctx.RetL(true)
}

// pgTLSSelfSigned writes a fresh self-signed ECDSA P-256 cert
// and installs it. Dev-only — production should ship a CA-signed
// cert. PRG signature:
//
//	pg_tls_self_signed( cCertPath, cKeyPath, cHostname ) -> .T. | cErr
func pgTLSSelfSigned(ctx *hbrt.HBContext) {
	if ctx.PCount() < 3 || !ctx.IsChar(1) || !ctx.IsChar(2) || !ctx.IsChar(3) {
		ctx.RetC("pg_tls_self_signed: cert path, key path, hostname required")
		return
	}
	if err := GenerateSelfSignedCert(ctx.ParC(1), ctx.ParC(2), ctx.ParC(3)); err != nil {
		ctx.RetC(err.Error())
		return
	}
	ctx.RetL(true)
}

// pgAllowIP appends a CIDR range to the source-IP allowlist. PRG
// signature:
//
//	pg_allow_ip( cCIDR ) -> .T. | cErr
//
// Repeated calls accumulate; pg_clear_allowlist() resets to
// "allow anyone". An empty list means allow-all.
func pgAllowIP(ctx *hbrt.HBContext) {
	if ctx.PCount() < 1 || !ctx.IsChar(1) {
		ctx.RetC("pg_allow_ip: CIDR required")
		return
	}
	if err := AllowIP(ctx.ParC(1)); err != nil {
		ctx.RetC(err.Error())
		return
	}
	ctx.RetL(true)
}

// pgClearAllowList resets to allow-all. PRG signature:
//
//	pg_clear_allowlist() -> NIL
func pgClearAllowList(ctx *hbrt.HBContext) {
	ClearAllowList()
	ctx.RetNil()
}

// pgAddRole registers a (username, password) pair with the
// pgserver auth subsystem. Idempotent — re-adding the same name
// replaces the prior credential. PRG signature:
//
//	pg_add_role( cName, cPassword ) -> NIL
//
// Bootstrap pattern (combine with pg_server_start):
//
//	pg_add_role( "alice", "swordfish" )
//	pg_add_role( "bob",   "hunter2"   )
//	pg_server_start( 5432, "md5" )
func pgAddRole(ctx *hbrt.HBContext) {
	if ctx.PCount() < 2 || !ctx.IsChar(1) || !ctx.IsChar(2) {
		ctx.RetNil()
		return
	}
	AddRole(ctx.ParC(1), ctx.ParC(2))
	ctx.RetNil()
}

// pgRemoveRole drops a previously-added role. PRG signature:
//
//	pg_remove_role( cName ) -> NIL
func pgRemoveRole(ctx *hbrt.HBContext) {
	if ctx.PCount() < 1 || !ctx.IsChar(1) {
		ctx.RetNil()
		return
	}
	RemoveRole(ctx.ParC(1))
	ctx.RetNil()
}

func pgServerStart(ctx *hbrt.HBContext) {
	listen := ":5432"
	if ctx.PCount() >= 1 {
		if ctx.IsNumeric(1) {
			listen = ":" + strconv.Itoa(ctx.ParNI(1))
		} else if ctx.IsChar(1) {
			listen = ctx.ParC(1)
		}
	}
	cfg := Config{Listen: listen}
	if ctx.PCount() >= 2 && ctx.IsChar(2) {
		cfg.AuthMode = ctx.ParC(2)
	}
	// Inhale any pending TLS config installed by PG_TLS_LOAD /
	// PG_TLS_SELF_SIGNED before this call. Server keeps a snapshot;
	// later TLS changes won't affect an already-running listener.
	cfg.TLSConfig = CurrentTLSConfig()
	srv := NewServer(ctx.T.VM(), cfg)
	srv.allowList = CurrentAllowList()
	setActiveServer(srv)
	tlsNote := ""
	if cfg.TLSConfig != nil {
		tlsNote = " tls=on"
	}
	allowNote := ""
	if len(srv.allowList) > 0 {
		allowNote = fmt.Sprintf(" allowlist=%d", len(srv.allowList))
	}
	fmt.Fprintf(os.Stderr, "pgserver: listening on %s (auth=%s%s%s)\n",
		cfg.listenAddr(), defaultStr(cfg.AuthMode, "trust"), tlsNote, allowNote)
	if err := srv.Serve(context.Background()); err != nil {
		fmt.Fprintf(os.Stderr, "pgserver: %v\n", err)
	}
	ctx.RetNil()
}

func pgServerStop(ctx *hbrt.HBContext) {
	if srv := takeActiveServer(); srv != nil {
		_ = srv.Close()
	}
	ctx.RetNil()
}

func defaultStr(s, fallback string) string {
	if s == "" {
		return fallback
	}
	return s
}

// activeServer tracks the most recently started server so
// pg_server_stop() can find it without the PRG layer needing to
// hold a handle. v1.0 is single-server-per-process; a future
// upgrade can swap this for a slice.
var activeServerSlot *Server

func setActiveServer(s *Server) { activeServerSlot = s }
func takeActiveServer() *Server {
	s := activeServerSlot
	activeServerSlot = nil
	return s
}